/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {
  numDefine98,
  numDefine99,
  numDefine100,
  numDefine101,
  numDefine102,
  numDefine103,
  numDefine128,
  numDefine140,
  numDefine107,
  numDefine111,
  numDefine146,
  numDefine108,
  numDefine109,
  numDefine110,
  numDefine104,
  numDefine105,
  numDefine106,
  numDefine28,
  numDefine2,
  numDefine13,
  numDefine19,
  numDefine18,
  numDefine3,
  numDefine16,
  numDefine5,
  numDefine6,
  numDefine7,
  numDefine8,
  numDefine141,
  numDefine150,
  numDefine155,
  numDefine156,
  numDefine165,
  numDefine172,
  numDefine173,
  numDefine29,
  numDefine20,
  numDefine14,
  numDefine72,
  numDefine73,
  numDefine83645,
  numDefine74,
  numDefine75,
  numDefine76,
  numDefine77,
  numDefineNeg13,
  numDefine258,
  numDefine207,
  numDefine78,
  numDefine79,
  numDefine81,
  numDefine83,
  numDefine85,
  numDefine87,
  numDefine88,
  numDefine90,
  numDefine92,
  numDefine93,
  numDefine96,
  numDefine97,
  numDefine30,
  numDefine21,
  numDefine31,
  numDefine06431,
  numDefine22,
  numDefine32,
  numDefine23,
  numDefine33,
  numDefine10,
  numDefine9,
  numDefine4,
  numDefine15,
  numDefine11,
  numDefine48,
  numDefineNeg2,
  numDefine46,
  numDefineNeg8,
  numDefine64,
  numDefine58,
  numDefine65535,
  numDefineNeg16,
  numDefine27,
  numDefine17,
  numDefine12,
  numDefine255,
  numDefineNeg24,
  numDefine54,
  numDefineNeg4,
  numDefine24,
  numDefineNeg40,
  numDefineNeg6,
  numDefineNeg12,
  numDefineNeg3,
  numDefine40,
  numDefine47,
  numDefine36,
  numDefine69,
  numDefine61,
  numDefine50,
  numDefine25,
  numDefine67,
  numDefine26,
  numDefine63,
  numDefine38,
  numDefine42,
  numDefine71,
  numDefine39,
  numDefine45,
  numDefine34,
  numDefine43,
  numDefine44,
  numDefine49,
  numDefine68,
  numDefine65,
  numDefine41,
  numDefine66,
  numDefine57,
  numDefine52,
  numDefine51,
  numDefine35,
  numDefine37,
  numDefine113,
  numDefine70,
  numDefine120,
  numDefine256,
  numDefine53,
  numDefine60,
  numDefine1000,
  numDefine55765,
  numDefine93459,
  numDefine45135,
  numDefine11935,
  numDefine67296,
  numDefineNeg7,
  numDefineNeg5,
  numDefineNeg16408,
  numDefineNeg4097,
  numDefineNeg16384,
  numDefineNeg83648,
  numDefine83647,
  numDefineNeg48,
  numDefine114,
  numDefine119,
  numDefine112,
  numDefine62,
  numDefine115,
  numDefine117,
  numDefine167,
  numDefine176,
  numDefine121,
  numDefine35072,
  numDefine2047,
  numDefineNeg1023,
  numDefineFloat101,
  numDefineNeg32,
  numDefineNeg80,
  numDefineNeg64,
  numDefine2048,
  numDefineN6,
  numDefineNeg65,
  numDefine55,
  numDefine59,
  numDefine332,
  numDefine264,
  numDefine244,
  numDefine32767,
  numDefineNeg288,
  numDefineNeg304,
  numDefineNeg256,
  numDefineNeg280,
  numDefineNeg264,
  numDefineNeg624,
  numDefineNeg368,
  numDefineNeg56,
  numDefine127,
  numDefine126,
  numDefineNeg640,
  numDefineNeg66,
  numDefineNeg128,
  numDefine214,
  numDefineNeg132,
  numDefineNeg528,
  numDefine284,
  numDefine175,
  numDefine242,
  numDefine278,
  numDefineNeg72,
  numDefineNeg14,
  numDefineNeg384,
  numDefineNeg352,
  numDefineNeg28,
  numDefineNeg1408,
  numDefineNeg26,
  numDefineNeg55,
  numDefineNeg87,
  numDefineNeg101,
  numDefineNeg9,
  numDefineNeg31,
  numDefine97152,
  numDefineNeg520,
  numDefineNeg37,
  numDefineNeg33,
  numDefine130,
  numDefineNeg127,
  numDefine125,
  numDefine35457,
  numDefine168,
  numDefine232,
  numDefine260,
  numDefine268,
  numDefine269,
  numDefine286,
  numDefine292,
  numDefine296,
  numDefineNeg150,
  numDefine224,
  numDefine08863,
  numDefine8193,
  numDefine49158,
  numDefine83160,
  numDefine40928,
  numDefine68896,
  numDefine58528,
  numDefine325,
  numDefine65600,
  numDefineNeg259,
  numDefine48575,
  numDefine48576,
  numDefine1075,
  numDefineNeg1075,
  numDefine88607,
  numDefine88608,
  numDefine31072,
  numDefineNeg16392,
  numDefineNeg2064,
  numDefineNeg2048,
  numDefine93248,
  numDefineNeg2456,
  numDefine187,
  numDefineNeg2432,
  numDefine250,
  numDefine314,
  numDefine304,
  numDefine323,
  numDefine331,
  numDefine343,
  numDefine359,
  numDefine350,
  numDefineNeg2440,
  numDefineNeg610,
  numDefineNeg32788,
  numDefineNeg32792,
  numDefineNeg95124,
  numDefineNeg88608,
  numDefine95040,
  numDefine905,
  numDefine24288,
  numDefine94303,
  numDefine24096,
  numDefine1054,
  numDefineNeg72672,
  numDefineNeg10976,
  numDefine10976,
  numDefine897,
  numDefine70911,
  numDefine89344,
  numDefine35456,
  numDefine41824,
  numDefine41825,
  numDefine77216,
  numDefine53216,
  numDefineNeg32784,
  numDefineNeg32768,
  numDefine8198,
  numDefine8196,
  numDefine32792,
  numDefine8194,
  numDefine8192,
  numDefine1023,
  numDefine1656,
  numDefine16384,
  numDefine361,
  numDefine341,
  numDefine307,
  numDefine621,
  numDefine32768,
  numDefine3553,
  numDefine6408,
  numDefine5121
} from './mandreel-part1/Class/DevNumber';

import {
  llvmWriteDouble,
  printf,
  mallocNew,
  puts,
  twoEStr785,
  zzn4Rw11RwLocale9CManageEPS0PKcE9nLocales,
  vsnprintf,
  sandboxOutputDebugString,
  zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize,
  vPrintf,
  functionTable,
  zzn4Rw11RwLocale9CManageEPS0PKcE7locales,
  blockMergeNext,
  strtol,
  myArgTest,
  zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf,
  strcpy,
  zzn4Rw11RwLocale9CManageEPS0PKcE7classic,
  uint,
  free,
  zdlPv,
  assertNew,
  znwj,
  zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody,
  jsMandreelFlashTcpUpdate,
  zn4RwL12RwClassicE,
  twoEStr12102177,
  twoEStr4131,
  mandreelAddValidFopenfile,
  zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE12nStdFacets,
  zn4Rw9RwCatsE,
  zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE10stdFacets,
  mandreelAudioIsLogEnabled,
  zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE17stdFacetBufsize,
  mandreelAudioGetAudioDriverName,
  zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf,
  mandreelFtell,
  mandreelFeof,
  mandreelFclose,
  mandreelFread,
  swriteIndex,
  zzn4Rw11RwLocale9CManageEPS0PKcE6global,
  realloc,
  mandreelUngetc,
  znaj,
  mandreelFseek,
  zzn4Rw11RwLocale9CManageEPS0PKcE5ginit,
  twoEStr5134,
  mandreelWritels,
  zzn4RwL13RwVfmtwhatEPcjiS0E7Fname,
  zzn4RwL13RwVfmtwhatEPcjiS0E6buffer,
  mandreelWritecloud,
  zzn4RwL13RwVfmtwhatEPcjiS0E8Catset,
  zzn4RwL13RwVfmtwhatEPcjiS0E4msgs,
  mandreelOpenls,
  ztvst8messagesIcE,
  zn4RwL22RwClassicOnceInitE2E02EB,
  twoEStr15132,
  twoEStr47,
  mandreelReadcloud,
  twoEStr10100175,
  zzn4RwL13RwVfmtwhatEPcjiS0E5Cat,
  zzn4Rw10RwThrowEizE6errors,
  mandreelFopen,
  zn4RwL13RwWhatBufE,
  zn4RwL16RwWhatRefcntE,
  abort,
  mandreelReadls,
  twoEStr221,
  getTimeOfDay,
  twoEStr27248,
  strcmp,
  iMandreelRegisterExternalCallback,
  mandreelInternalCreateWindow,
  mandreelOpencloud,
  z30MandreelFopenEnableCheckfatb,
  mandreelTextureAsyncSetData,
  zgvz21MandreelGetTickCountE7sFirst,
  zz21MandreelGetTickCountE7sFirst,
  zn4RwL12RwCatlistE2E1,
  zn4RwL12RwCatlistE2E0,
  ztvn4Rw10RwFacetE,
  twoEStr538,
  twoEStr292167
} from './commonFile';
import { commonVariable, heapClassInst } from './mandreel-part1/Class/CommonClassFile';
import {
  twoEStr33679,
  zz29MandreelInternalPreupdateE8sBfirst2EB,
  twoEStr35681,
  zzn4Rw10RwFacetD4EvE9destroyed,
  zn5myGlL9mContextE,
  zl15gIFreeChannels,
  twoEStr3361,
  twoEStr32678,
  sCurrentMemory,
  blockNull,
  zl13sFifoErrors,
  zl13sFileStdout,
  twoEStr4362,
  twoEStr4651,
  twoEStr5652,
  twoEStr1222,
  twoEStr26,
  znss11CNullRefE,
  twoEStr37683,
  zl26sMandreelInternalHeight,
  ztvst9typeInfo,
  zl15gAFreeChannels,
  twoEStr115180,
  twoEStr2360,
  zl25sMandreelInternalWidth,
  zl24gPFirstTextureAsyncInfo,
  twoEStr1648,
  twoEStr31677,
  zl17gApPackFileNames,
  zl10sASockets,
  twoEStr1116181,
  zn12mandreelB64L11b64IndexesE,
  zz24MandreelInternalInitE54s723478567MandreelMandreelInternalSetResolution,
  twoEStr34680,
  twoEStr5784,
  ztv10CFileCloud,
  zdaPv,
  zzn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEEE11localeRoot,
  twoEStr4225,
  twoEStr28249,
  twoEStr3224,
  twoEStr4133,
  memcpy,
  twoEStr12233,
  twoEStr2131,
  twoEStr30251,
  twoEStr31252,
  zl21gPFirstSoundDuration,
  myCtype,
  twoEStr7136,
  zl10strtokPos,
  ztv7CFileLS,
  zzl32MandreelInitTcpSocketLibrayvE47s723478567MandreelMandreelFlashTcpOnError,
  zn12mandreelB64L9b64CharsE,
  twoEStr3133,
  ztv11CFileSystem,
  twoEStr4783,
  twoEStr6785,
  twoEStr34255,
  gMsgcallback,
  zl11gAChannels,
  llvmReadDouble,
  twoEStr3782,
  twoEStr24245,
  twoEStr26247,
  twoEStr29250,
  twoEStr32253,
  twoEStr33254,
  zz24MandreelInternalInitE56s723478567MandreelIMandreelTextureAsyncIsCompressed,
  zl7gBInit2EB,
  zl6gBLog,
  twoEStr35256,
  twoEStr22243,
  twoEStr779,
  zz24MandreelInternalInitE57s723478567MandreelIMandreelTextureAsyncGetPackOffset,
  zz24MandreelInternalInitE46s723478567MandreelImandreelViewportResize,
  zz24MandreelInternalInitE29s723478567MandreelResize,
  zz24MandreelInternalInitE48s723478567MandreelImandreelRestoreGlcontext,
  zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE4init2EB,
  zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize,
  zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs,
  zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs,
  zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat,
  zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf
} from './commonFile';
import {
  mandreelAudioInit,
  mandreelAudioStopChannel,
  mandreelAudioUpdate,
  mandreelAudioCreateBuffer,
  mandreelAudioUseMusicFunctionsNew
} from './mandreelFile1';

function zn4RwL13RwVfmtwhatEPcjPKcS0(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = zn4RwL16RwWhatRefcntE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = (r1 + 1) | 0;
  heapClassInst.heap32[r0] = r4;
  if (r1 !== 0) {
    heapClassInst.heap32[g0] = numDefine256;
    znaj(i7);
    r1 = commonVariable.rg0;
    r4 = heapClassInst.heap32[r0];
    r4 = (r4 + -1) | 0;
    heapClassInst.heap32[r0] = r4;
  } else {
    r1 = zn4RwL13RwWhatBufE;
  }
  r4 = numDefine256;
  r12 = swriteIndex.swriteIndexNew;
  repeat5: while (true) {
    r5 = sp + numDefineNeg16;
    heapClassInst.heap32[fp + numDefineNeg8] = r3;
    r6 = r5 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg7] = r3;
    r7 = (r4 + -1) | 0;
    r8 = 0;
    heapClassInst.heap32[r6 + 1] = 0;
    r9 = sp + numDefineNeg24;
    r10 = r4 === 0 ? r8 : r7;
    heapClassInst.heap32[fp + numDefineNeg4] = r1;
    r11 = r9 >> numDefine2;
    heapClassInst.heap32[r6 + numDefine2] = r10;
    heapClassInst.heap32[r11 + 1] = r12;
    heapClassInst.heap32[fp + numDefineNeg6] = r5;
    heapClassInst.heap32[g0] = r9;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    vPrintf(i7);
    r5 = commonVariable.rg0;
    repeat7: do {
      if (!(r1 === 0)) {
        if (!(r4 === 0)) {
          if (!(r5 < 0)) {
            if (!(r4 === -1)) {
              if (!(uint(r5) < uint(r4))) {
                heapClassInst.heap8[r1 + r7] = r8;
                break repeat7;
              }
            }
            heapClassInst.heap8[r1 + r5] = r8;
          }
        }
      }
    } while (false);
    r5 = r5 < 0 ? r8 : r5;
    r5 = r7 > r5 ? r5 : r8;
    if (r5 !== 0) {
      if (r4 > r5) {
        break repeat5;
      } else {
        r4 = (r5 + 1) | 0;
      }
    } else {
      r4 = r4 << 1;
    }
    r5 = zn4RwL13RwWhatBufE;
    if (r1 !== r5) {
      if (!(r1 === 0)) {
        heapClassInst.heap32[g0] = r1;
        zdaPv(i7);
      }
    } else {
      r1 = heapClassInst.heap32[r0];
      r1 = (r1 + -1) | 0;
      heapClassInst.heap32[r0] = r1;
    }
    heapClassInst.heap32[g0] = r4;
    znaj(i7);
    r1 = commonVariable.rg0;
    continue repeat5;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn4Rw11RwLocale11CGetBodyEPS0S1PKciPKNS10RwFacetE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg304;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg264;
  r1 = (r0 + numDefine8) | 0;
  r2 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg66] = 0;
  r3 = 0;
  heapClassInst.heap32[r2 + 1] = r1;
  heapClassInst.heap8[sp + numDefineNeg256] = r3;
  r4 = twoEStr538;
  r5 = twoEStr292167;
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = numDefine2;
  strncmp(i7);
  r5 = commonVariable.rg0;
  repeat1: do {
    if (r5 === 0) {
      r4 = sp + numDefineNeg288;
      r5 = r4 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg72] = 0;
      heapClassInst.heap32[r5 + 1] = 0;
      heapClassInst.heap32[r5 + numDefine2] = 0;
      heapClassInst.heap32[r5 + numDefine3] = 0;
      r6 = numDefine4;
      heapClassInst.heap32[r5 + numDefine4] = 0;
      heapClassInst.heap32[r5 + numDefine5] = 0;
      repeat3: while (true) {
        r6 = (r6 + numDefineNeg4) | 0;
        if (!(r6 !== 0)) {
          break repeat3;
        }
      }
      r5 = twoEStr538;
      repeat6: while (true) {
        r6 = heapClassInst.heapU8[r5];
        if (r6 === 0) {
          label = numDefine44;
          break repeat6;
        } else {
          r6 = r3;
          r7 = r3;
          repeat9: while (true) {
            r8 = (r5 + r6) | 0;
            r9 = heapClassInst.heapU8[r5 + r6];
            if (r9 === numDefine59) {
              label = numDefine16;
              break repeat9;
            } else {
              if (r9 !== 0) {
                r9 = heapClassInst.heapU8[r8 + 1];
                if (r9 === 0) {
                  label = numDefine6;
                  break repeat9;
                } else {
                  if (r9 === numDefine59) {
                    label = numDefine18;
                    break repeat9;
                  } else {
                    r9 = heapClassInst.heapU8[r8 + numDefine2];
                    if (r9 === 0) {
                      label = numDefine6;
                      break repeat9;
                    } else {
                      r10 = r7 << numDefine2;
                      if (r9 !== numDefine59) {
                        r8 = heapClassInst.heapU8[r8 + numDefine3];
                        if (r8 === 0) {
                          label = numDefine6;
                          break repeat9;
                        } else {
                          if (r8 !== numDefine59) {
                            r7 = (r7 + 1) | 0;
                            r6 = (r6 + numDefine4) | 0;
                          } else {
                            label = numDefine14;
                            break repeat9;
                          }
                        }
                      } else {
                        label = numDefine11;
                        break repeat9;
                      }
                    }
                  }
                }
              } else {
                label = numDefine6;
                break repeat9;
              }
            }
          }
          repeat19: do {
            switch (label) {
              case numDefine16:
                if (r8 === 0) {
                  label = numDefine6;
                  break repeat19;
                } else {
                  label = numDefine19;
                  break repeat19;
                }
              case numDefine18:
                r8 = (r8 + 1) | 0;
                label = numDefine19;
                break repeat19;
              case numDefine14:
                r6 = r10 | numDefine3;
                r8 = (r5 + r6) | 0;
                label = numDefine19;
                break repeat19;
              case numDefine11:
                r6 = r10 | numDefine2;
                r8 = (r5 + r6) | 0;
                label = numDefine19;
                break;
              default:
                break;
            }
          } while (false);
          repeat24: do {
            if (label === numDefine6) {
              r6 = r5;
              while (true) {
                r8 = (r6 + 1) | 0;
                r7 = heapClassInst.heapU8[r6 + 1];
                r6 = r8;
                if (!(r7 !== 0)) {
                  break repeat24;
                }
              }
            }
          } while (false);
          r6 = 0;
          r7 = r6;
          repeat29: while (true) {
            r9 = (r5 + r6) | 0;
            r10 = heapClassInst.heapU8[r5 + r6];
            if (r10 === numDefine61) {
              label = numDefine32;
              break repeat29;
            } else {
              if (r10 !== 0) {
                r10 = heapClassInst.heapU8[r9 + 1];
                if (r10 === 0) {
                  label = numDefine22;
                  break repeat6;
                } else {
                  if (r10 === numDefine61) {
                    label = numDefine33;
                    break repeat29;
                  } else {
                    r10 = heapClassInst.heapU8[r9 + numDefine2];
                    if (r10 === 0) {
                      label = numDefine22;
                      break repeat6;
                    } else {
                      r11 = r7 << numDefine2;
                      if (r10 !== numDefine61) {
                        r9 = heapClassInst.heapU8[r9 + numDefine3];
                        if (r9 === 0) {
                          label = numDefine22;
                          break repeat6;
                        } else {
                          if (r9 !== numDefine61) {
                            r7 = (r7 + 1) | 0;
                            r6 = (r6 + numDefine4) | 0;
                          } else {
                            label = numDefine30;
                            break repeat29;
                          }
                        }
                      } else {
                        label = numDefine27;
                        break repeat29;
                      }
                    }
                  }
                }
              } else {
                label = numDefine22;
                break repeat6;
              }
            }
          }
          switch (label) {
            case numDefine32:
              if (r9 === 0) {
                label = numDefine22;
                break repeat6;
              }
              break;
            case numDefine33:
              r9 = (r9 + 1) | 0;
              break;
            case numDefine30:
              r6 = r11 | numDefine3;
              r9 = (r5 + r6) | 0;
              break;
            case numDefine27:
              r6 = r11 | numDefine2;
              r9 = (r5 + r6) | 0;
              break;
            default:
              break;
          }
          r6 = (r9 - r5) | 0;
          r7 = 0;
          repeat45: while (true) {
            if (r7 !== numDefineNeg6) {
              r10 = (r7 * numDefineNeg3) | 0;
              r11 = zn4Rw9RwCatsE;
              r10 = r10 << numDefine2;
              r10 = (r11 + r10) | 0;
              r10 = r10 >> numDefine2;
              r10 = heapClassInst.heap32[r10 + 1];
              heapClassInst.heap32[g0] = r10;
              heapClassInst.heap32[g0 + 1] = r5;
              heapClassInst.heap32[g0 + numDefine2] = r6;
              strncmp(i7);
              r10 = commonVariable.rg0;
              if (r10 !== 0) {
                r7 = (r7 + -1) | 0;
              } else {
                label = numDefine36;
                break repeat45;
              }
            } else {
              label = numDefine40;
              break repeat45;
            }
          }
          if (label === numDefine36) {
            r6 = r7 << numDefine2;
            r6 = (r4 - r6) | 0;
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            if (r6 !== 0) {
              label = numDefine22;
              break repeat6;
            } else {
              r6 = 0;
              r6 = (r6 - r7) | 0;
              r6 = r6 << numDefine2;
              r6 = (r4 + r6) | 0;
              r6 = r6 >> numDefine2;
              r7 = (r9 + 1) | 0;
              heapClassInst.heap32[r6] = r7;
            }
          }
          r6 = heapClassInst.heapU8[r8];
          r5 = r8;
          if (r6 === 0) {
            label = numDefine42;
          } else {
            r5 = (r8 + 1) | 0;
          }
        }
      }
      switch (label) {
        case numDefine44:
          r3 = 0;
          r5 = r3;
          repeat56: while (true) {
            if (r5 !== numDefineNeg6) {
              r6 = (r3 - r5) | 0;
              r6 = r6 << numDefine2;
              r6 = (r4 + r6) | 0;
              r6 = r6 >> numDefine2;
              r7 = heapClassInst.heap32[r6];
              if (r7 === 0) {
                r7 = twoEStr538;
                heapClassInst.heap32[r6] = r7;
              }
              r6 = 0;
              r8 = r6;
              repeat62: while (true) {
                r9 = heapClassInst.heapU8[r7 + r6];
                if (r9 === 0) {
                  label = numDefine60;
                  break repeat62;
                } else {
                  r10 = (r7 + r6) | 0;
                  if (r9 === numDefine59) {
                    label = numDefine59;
                    break repeat62;
                  } else {
                    r9 = heapClassInst.heapU8[r10 + 1];
                    if (r9 === 0) {
                      label = numDefine60;
                      break repeat62;
                    } else {
                      if (r9 === numDefine59) {
                        label = numDefine65;
                        break repeat62;
                      } else {
                        r9 = heapClassInst.heapU8[r10 + numDefine2];
                        if (r9 === 0) {
                          label = numDefine60;
                          break repeat62;
                        } else {
                          r11 = r8 << numDefine2;
                          if (r9 !== numDefine59) {
                            r10 = heapClassInst.heapU8[r10 + numDefine3];
                            if (r10 === 0) {
                              label = numDefine60;
                              break repeat62;
                            } else {
                              if (r10 !== numDefine59) {
                                r8 = (r8 + 1) | 0;
                                r6 = (r6 + numDefine4) | 0;
                              } else {
                                label = numDefine57;
                                break repeat62;
                              }
                            }
                          } else {
                            label = numDefine54;
                            break repeat62;
                          }
                        }
                      }
                    }
                  }
                }
              }
              repeat72: do {
                switch (label) {
                  case numDefine59:
                    if (r10 === 0) {
                      label = numDefine60;
                      break repeat72;
                    } else {
                      label = numDefine66;
                      break repeat72;
                    }
                  case numDefine65:
                    r10 = (r10 + 1) | 0;
                    label = numDefine66;
                    break repeat72;
                  case numDefine57:
                    r6 = r11 | numDefine3;
                    r10 = (r7 + r6) | 0;
                    label = numDefine66;
                    break repeat72;
                  case numDefine54:
                    r6 = r11 | numDefine2;
                    r10 = (r7 + r6) | 0;
                    label = numDefine66;
                    break;
                  default:
                    break;
                }
              } while (false);
              if (label === numDefine60) {
                r10 = heapClassInst.heapU8[r7];
                repeat79: do {
                  if (r10 !== 0) {
                    r6 = (r7 + 1) | 0;
                    r8 = 0;
                    while (true) {
                      r10 = (r8 + 1) | 0;
                      r9 = heapClassInst.heapU8[r6 + r8];
                      r8 = r10;
                      if (!(r9 !== 0)) {
                        break repeat79;
                      }
                    }
                  } else {
                    r10 = 0;
                  }
                } while (false);
                r10 = (r7 + r10) | 0;
              }
              r6 = (r10 - r7) | 0;
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r7;
              heapClassInst.heap32[g0 + numDefine2] = r6;
              zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(i7);
              r6 = twoEStr785;
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r6;
              heapClassInst.heap32[g0 + numDefine2] = 1;
              zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(i7);
              r5 = (r5 + -1) | 0;
            } else {
              break repeat56;
            }
          }
          r4 = heapClassInst.heap32[r2 + 1];
          if (r4 === 0) {
            heapClassInst.heap32[g0] = 0;
            heapClassInst.heap32[g0 + 1] = 0;
            zn4Rw11RwLocale9CManageEPS0PKc(i7);
            r4 = commonVariable.rg0;
            label = numDefine73;
            break repeat1;
          } else {
            label = numDefine72;
            break repeat1;
          }
        case numDefine22:
          r4 = 0;
          label = numDefine73;
          break;
        default:
          break;
      }
    } else {
      label = numDefine72;
    }
  } while (false);
  if (label === numDefine72) {
    heapClassInst.heap32[g0] = 0;
    heapClassInst.heap32[g0 + 1] = r4;
    zn4Rw11RwLocale9CManageEPS0PKc(i7);
    r4 = commonVariable.rg0;
  }
  r0 = heapClassInst.heap32[r2 + 1];
  if (!(r0 === r1)) {
    if (!(r0 === 0)) {
      heapClassInst.heap32[g0] = r0;
      zdaPv(i7);
    }
  }
  commonVariable.rg0 = r4;
  return;
}

function zn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4E(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE12nStdFacets;
  r1 = zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE10stdFacets;
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[r0];
  r4 = heapClassInst.heap32[r1];
  repeat1: do {
    if (r2 === 0) {
      r5 = heapClassInst.heap32[fp + 1];
      r2 = heapClassInst.heap32[fp + numDefine2];
      r6 = heapClassInst.heap32[fp + numDefine3];
      r7 = twoEStr538;
      r8 = r2 === 0 ? r7 : r2;
      r9 = r3;
      repeat3: while (true) {
        r10 = r9;
        if (r10 === 0) {
          label = numDefine34;
          break repeat3;
        } else {
          r9 = r10 << 1;
          r11 = r9 & numDefineNeg4;
          r12 = (r4 + r11) | 0;
          r9 = r12 >> numDefine2;
          r13 = heapClassInst.heap32[r9];
          r14 = r13 >> numDefine2;
          r15 = heapClassInst.heap32[r14 + numDefine5];
          r9 = r10 >>> 1;
          if (r15 !== r5) {
            r15 = (r15 - r5) | 0;
          } else {
            r15 = heapClassInst.heap32[r14 + 1];
            r15 = r15 === 0 ? r7 : r15;
            heapClassInst.heap32[g0] = r8;
            heapClassInst.heap32[g0 + 1] = r15;
            strcmp(i7);
            r15 = commonVariable.rg0;
          }
          if (r15 < 0) {
            label = numDefine31;
          } else {
            if (r15 < 1) {
              label = numDefine32;
              break repeat3;
            } else {
              r4 = (r11 + r4) | 0;
              r10 = (r10 + -1) | 0;
              r4 = (r4 + numDefine4) | 0;
              r9 = (r10 - r9) | 0;
            }
          }
        }
      }
      if (label === numDefine32) {
        if (!(r12 === 0)) {
          r2 = heapClassInst.heap32[r14 + numDefine6];
          r2 = (r2 + 1) | 0;
          heapClassInst.heap32[r14 + numDefine6] = r2;
          commonVariable.rg0 = r13;
          return;
        }
      }
      r4 = zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE17stdFacetBufsize;
      r4 = r4 >> numDefine2;
      r7 = heapClassInst.heap32[r4];
      if (!(r3 !== r7)) {
        r3 = r3 << numDefine3;
        heapClassInst.heap32[g0] = r3;
        znaj(i7);
        r3 = commonVariable.rg0;
        r7 = heapClassInst.heap32[r1];
        r8 = heapClassInst.heap32[r0];
        r8 = r8 << numDefine2;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = r8;
        memcpy(i7);
        r8 = zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf;
        if (!(r7 === r8)) {
          if (!(r7 === 0)) {
            heapClassInst.heap32[g0] = r7;
            zdaPv(i7);
          }
        }
        heapClassInst.heap32[r1] = r3;
        r3 = heapClassInst.heap32[r4];
        r3 = r3 << 1;
        heapClassInst.heap32[r4] = r3;
      }
      r3 = r5 & 1;
      r4 = 0;
      r2 = r3 === 0 ? r2 : r4;
      heapClassInst.heap32[g0] = 1;
      heapClassInst.heap32[g0 + 1] = r2;
      functionTable[r6 >> numDefine2](i7);
      r2 = commonVariable.rg0;
      r3 = (r5 + 1) | 0;
      r4 = r3 >>> numDefine31;
      r6 = r2 >> numDefine2;
      r3 = (r3 + r4) | 0;
      r4 = heapClassInst.heap32[r6 + numDefine7];
      r4 = r4 >> numDefine2;
      r3 = r3 >> 1;
      heapClassInst.heap32[r4] = r3;
      r3 = heapClassInst.heap32[r6 + numDefine5];
      if (!(r3 === r5)) {
        r3 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine5] = r5;
      }
      r3 = r2 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine6];
      if (!(r4 === 1)) {
        heapClassInst.heap32[r3 + numDefine6] = 1;
      }
      r3 = heapClassInst.heap32[r0];
      r1 = heapClassInst.heap32[r1];
      r4 = r3 << numDefine2;
      r4 = (r1 + r4) | 0;
      r4 = r4 >> numDefine2;
      r5 = (r3 + 1) | 0;
      heapClassInst.heap32[r4] = r2;
      heapClassInst.heap32[r0] = r5;
      r0 = (r3 + -1) | 0;
      if (uint(r0) < uint(numDefine83645)) {
        r0 = swriteIndex.cmpfacetsIndex;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        quicksort(i7);
      }
    } else {
      r5 = r3;
      r6 = r4;
      repeat31: while (true) {
        r7 = r5;
        if (r7 === 0) {
          label = numDefine23;
          break repeat31;
        } else {
          r5 = r7 << 1;
          r8 = r5 & numDefineNeg4;
          r9 = (r6 + r8) | 0;
          r5 = r9 >> numDefine2;
          r5 = heapClassInst.heap32[r5];
          r10 = r2 >> numDefine2;
          r11 = r5 >> numDefine2;
          r12 = heapClassInst.heap32[r10 + numDefine5];
          r13 = heapClassInst.heap32[r11 + numDefine5];
          r5 = r7 >>> 1;
          if (r12 !== r13) {
            r12 = (r13 - r12) | 0;
          } else {
            r12 = heapClassInst.heap32[r11 + 1];
            r13 = heapClassInst.heap32[r10 + 1];
            r10 = twoEStr538;
            r13 = r13 === 0 ? r10 : r13;
            r12 = r12 === 0 ? r10 : r12;
            heapClassInst.heap32[g0] = r13;
            heapClassInst.heap32[g0 + 1] = r12;
            strcmp(i7);
            r12 = commonVariable.rg0;
          }
          if (r12 < 0) {
            label = numDefine8;
          } else {
            if (r12 < 1) {
              label = numDefine9;
              break repeat31;
            } else {
              r6 = (r8 + r6) | 0;
              r7 = (r7 + -1) | 0;
              r6 = (r6 + numDefine4) | 0;
              r5 = (r7 - r5) | 0;
            }
          }
        }
      }
      if (label === numDefine9) {
        if (!(r9 === 0)) {
          r2 = (r9 - r4) | 0;
          r5 = r2 & numDefineNeg4;
          r6 = (r4 + r5) | 0;
          r6 = r6 >> numDefine2;
          r6 = heapClassInst.heap32[r6];
          r7 = r6 >> numDefine2;
          r8 = heapClassInst.heap32[r7 + numDefine6];
          r8 = (r8 + -1) | 0;
          heapClassInst.heap32[r7 + numDefine6] = r8;
          if (r8 === 0) {
            r2 = r2 >> numDefine2;
            r8 = (r3 + -1) | 0;
            heapClassInst.heap32[r0] = r8;
            if (uint(r8) > uint(numDefine207)) {
              label = numDefine17;
            } else {
              r0 = zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf;
              if (r4 === r0) {
                label = numDefine17;
              } else {
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = r5;
                r3 = r2 << numDefine2;
                r5 = (r3 + r4) | 0;
                r2 = (r8 - r2) | 0;
                memcpy(i7);
                r3 = (r0 + r3) | 0;
                r8 = (r5 + numDefine4) | 0;
                r2 = r2 << numDefine2;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r8;
                heapClassInst.heap32[g0 + numDefine2] = r2;
                memcpy(i7);
                if (!(r4 === 0)) {
                  heapClassInst.heap32[g0] = r4;
                  zdaPv(i7);
                }
                heapClassInst.heap32[r1] = r0;
                label = numDefine20;
              }
            }
            repeat51: do {
              if (label === numDefine17) {
                r0 = (r8 - r2) | 0;
                r0 = r0 << numDefine2;
                if (!(r0 === 0)) {
                  r0 = r3 << numDefine2;
                  r2 = r2 << numDefine2;
                  r0 = (r0 + numDefineNeg4) | 0;
                  r1 = (r2 + r4) | 0;
                  r2 = (r0 - r2) | 0;
                  r0 = (r1 + numDefine4) | 0;
                  while (true) {
                    r1 = heapClassInst.heapU8[r0];
                    r2 = (r2 + -1) | 0;
                    r3 = (r0 + 1) | 0;
                    heapClassInst.heap8[r0 + numDefineNeg4] = r1;
                    r0 = r3;
                    if (!(r2 !== 0)) {
                      break repeat51;
                    }
                  }
                }
              }
            } while (false);
            r2 = heapClassInst.heap32[r7 + 1];
            if (!(r2 === 0)) {
              if (!(r6 === 0)) {
                r2 = heapClassInst.heap32[r7];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + 1];
                heapClassInst.heap32[g0] = r6;
                functionTable[r2 >> numDefine2](i7);
                r2 = 0;
                commonVariable.rg0 = r2;
                return;
              }
            }
          }
          r2 = 0;
          break repeat1;
        }
      }
      r0 = r2 >> numDefine2;
      r1 = heapClassInst.heap32[r0 + numDefine6];
      r1 = (r1 + -1) | 0;
      heapClassInst.heap32[r0 + numDefine6] = r1;
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    }
  } while (false);
  commonVariable.rg0 = r2;
  return;
}

function zn4Rw11RwLocaleD2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine38];
  r3 = (r0 + numDefine112) | 0;
  if (r2 === r3) {
    label = numDefine2;
  } else {
    if (r2 !== 0) {
      r3 = 0;
      heapClassInst.heap32[g0] = r2;
      zdaPv(i7);
      label = numDefine4;
    } else {
      label = numDefine2;
    }
  }
  if (label === numDefine2) {
    r3 = 0;
  }
  repeat6: while (true) {
    r2 = r3 << numDefine2;
    r2 = (r0 - r2) | 0;
    r2 = r2 >> numDefine2;
    r4 = 0;
    r2 = heapClassInst.heap32[r2];
    if (!(r2 === 0)) {
      r5 = r2 >> numDefine2;
      r6 = heapClassInst.heap32[r5 + numDefine5];
      if (r6 === 0) {
        r2 = heapClassInst.heap32[r5 + numDefine6];
        r2 = (r2 + -1) | 0;
        heapClassInst.heap32[r5 + numDefine6] = r2;
        if (!(r2 !== 0)) {
          r2 = (r4 - r3) | 0;
          r2 = r2 << numDefine2;
          r2 = (r0 + r2) | 0;
          r2 = r2 >> numDefine2;
          r2 = heapClassInst.heap32[r2];
          if (!(r2 === 0)) {
            r5 = r2 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + 1];
            heapClassInst.heap32[g0] = r2;
            functionTable[r5 >> numDefine2](i7);
          }
        }
      } else {
        r5 = heapClassInst.heap32[r5 + 1];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = 0;
        zn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4E(i7);
      }
    }
    r3 = (r3 + -1) | 0;
    if (r3 !== numDefineNeg26) {
      continue repeat6;
    } else {
      break repeat6;
    }
  }
  r0 = heapClassInst.heap32[r1 + numDefine26];
  r2 = heapClassInst.heap32[r1 + numDefine27];
  repeat17: do {
    if (!(r2 === 0)) {
      repeat18: while (true) {
        r2 = r4 << numDefine2;
        r0 = (r0 + r2) | 0;
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r0 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r0 + numDefine6];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r0 + numDefine6] = r3;
        if (!(r3 !== 0)) {
          r0 = heapClassInst.heap32[r1 + numDefine26];
          r0 = (r0 + r2) | 0;
          r0 = r0 >> numDefine2;
          r0 = heapClassInst.heap32[r0];
          if (!(r0 === 0)) {
            r2 = r0 >> numDefine2;
            r2 = heapClassInst.heap32[r2];
            r2 = r2 >> numDefine2;
            r2 = heapClassInst.heap32[r2 + 1];
            heapClassInst.heap32[g0] = r0;
            functionTable[r2 >> numDefine2](i7);
          }
        }
        r4 = (r4 + 1) | 0;
        r0 = heapClassInst.heap32[r1 + numDefine26];
        r2 = heapClassInst.heap32[r1 + numDefine27];
        if (r4 !== r2) {
          continue repeat18;
        } else {
          break repeat17;
        }
      }
    }
  } while (false);
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r0;
    zdaPv(i7);
  }
  return;
}

function zn4Rw11RwLocaleC2EPKc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg280;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine26] = 0;
  heapClassInst.heap32[r1 + numDefine27] = 0;
  heapClassInst.heap32[r1 + numDefine39] = 1;
  r2 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[r1 + numDefine40] = 0;
  heapClassInst.heap32[r1 + numDefine41] = 0;
  r3 = heapClassInst.heapU8[r2];
  if (r3 === 0) {
    r3 = sp + numDefineNeg264;
    r4 = 0;
    r5 = r3 >> numDefine2;
    r6 = (r0 + numDefine112) | 0;
    heapClassInst.heap8[sp + numDefineNeg256] = r4;
    heapClassInst.heap32[r5 + 1] = r6;
    heapClassInst.heap32[fp + numDefineNeg66] = 0;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r2;
    r2 = (r3 + numDefine8) | 0;
    zn4RwL16RwExpandNameERNS14RwPodArrayIcLj256EEEPKc(i7);
    r3 = commonVariable.rg0;
    heapClassInst.heap32[r1 + numDefine38] = r3;
    heapClassInst.heap32[r5 + 1] = r2;
  } else {
    r3 = 1;
    repeat5: while (true) {
      r4 = (r3 + 1) | 0;
      r5 = heapClassInst.heapU8[r2 + r3];
      r3 = r4;
      if (!(r5 !== 0)) {
        break repeat5;
      }
    }
    if (uint(r4) > uint(numDefine39)) {
      heapClassInst.heap32[g0] = r4;
      znaj(i7);
      r3 = commonVariable.rg0;
    } else {
      r3 = (r0 + numDefine112) | 0;
    }
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    memcpy(i7);
    heapClassInst.heap32[r1 + numDefine38] = r3;
  }
  r2 = 0;
  heapClassInst.heap32[r1 + numDefine40] = numDefine08863;
  heapClassInst.heap32[r1 + numDefine41] = 0;
  repeat13: while (true) {
    r4 = (r3 - r2) | 0;
    r5 = heapClassInst.heapU8[r4];
    if (r5 === 0) {
      label = numDefine41;
      break repeat13;
    } else {
      if (r5 === numDefine59) {
        label = numDefine20;
        break repeat13;
      } else {
        r5 = heapClassInst.heapU8[r4 + 1];
        if (r5 === 0) {
          label = numDefine41;
          break repeat13;
        } else {
          if (r5 !== numDefine59) {
            r5 = heapClassInst.heapU8[r4 + numDefine2];
            if (r5 === 0) {
              label = numDefine41;
              break repeat13;
            } else {
              if (r5 === numDefine59) {
                label = numDefine14;
                break repeat13;
              } else {
                r4 = heapClassInst.heapU8[r4 + numDefine3];
                if (r4 === 0) {
                  label = numDefine41;
                  break repeat13;
                } else {
                  if (r4 === numDefine59) {
                    label = numDefine14;
                    break repeat13;
                  } else {
                    r2 = (r2 + numDefineNeg4) | 0;
                    continue repeat13;
                  }
                }
              }
            }
          } else {
            label = numDefine14;
            break repeat13;
          }
        }
      }
    }
  }
  if (label === numDefine20) {
    if (r3 === r2) {
      label = numDefine41;
    } else {
      label = numDefine14;
    }
  }
  repeat25: do {
    switch (label) {
      case numDefine41:
        r2 = heapClassInst.heapU8[r3];
        if (!(r2 !== numDefine67)) {
          r2 = heapClassInst.heapU8[r3 + 1];
          if (r2 === 0) {
            break repeat25;
          }
        }
        heapClassInst.heap32[r1 + numDefine41] = numDefine08863;
        break;
      case numDefine14:
        r2 = 0;
        r4 = r2;
        repeat31: while (true) {
          r5 = heapClassInst.heapU8[r3];
          if (r5 === 0) {
            break repeat25;
          } else {
            if (r2 !== numDefineNeg6) {
              r5 = r5 & numDefine255;
              if (r5 !== numDefine67) {
                label = numDefine23;
              } else {
                r5 = heapClassInst.heapU8[r3 + 1];
                if (r5 !== numDefine59) {
                  label = numDefine23;
                } else {
                  label = numDefine24;
                }
              }
              if (label === numDefine23) {
                r5 = (r2 * numDefineNeg3) | 0;
                r6 = zn4Rw9RwCatsE;
                r5 = r5 << numDefine2;
                r5 = (r6 + r5) | 0;
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5 + numDefine2];
                r4 = r5 | r4;
                heapClassInst.heap32[r1 + numDefine41] = r4;
              }
              r5 = 0;
              r6 = r3;
              repeat40: while (true) {
                r7 = heapClassInst.heapU8[r6];
                if (r7 === 0) {
                  break repeat25;
                } else {
                  if (r7 === numDefine59) {
                    label = numDefine36;
                    break repeat40;
                  } else {
                    r7 = heapClassInst.heapU8[r6 + 1];
                    if (r7 === 0) {
                      break repeat25;
                    } else {
                      if (r7 === numDefine59) {
                        label = numDefine37;
                        break repeat40;
                      } else {
                        r7 = heapClassInst.heapU8[r6 + numDefine2];
                        if (r7 === 0) {
                          break repeat25;
                        } else {
                          r8 = r5 << numDefine2;
                          if (r7 !== numDefine59) {
                            r7 = heapClassInst.heapU8[r6 + numDefine3];
                            if (r7 === 0) {
                              break repeat25;
                            } else {
                              if (r7 !== numDefine59) {
                                r5 = (r5 + 1) | 0;
                                r6 = (r6 + numDefine4) | 0;
                              } else {
                                label = numDefine34;
                                break repeat40;
                              }
                            }
                          } else {
                            label = numDefine31;
                            break repeat40;
                          }
                        }
                      }
                    }
                  }
                }
              }
              switch (label) {
                case numDefine36:
                  if (r6 === 0) {
                    break repeat25;
                  }
                  break;
                case numDefine37:
                  r6 = (r6 + 1) | 0;
                  break;
                case numDefine34:
                  r5 = r8 | numDefine3;
                  r6 = (r3 + r5) | 0;
                  break;
                case numDefine31:
                  r5 = r8 | numDefine2;
                  r6 = (r3 + r5) | 0;
                  break;
                default:
                  break;
              }
              r3 = (r6 + 1) | 0;
              r2 = (r2 + -1) | 0;
              continue repeat31;
            } else {
              break repeat25;
            }
          }
        }
      default:
        break;
    }
  } while (false);
  r1 = numDefine104;
  r3 = 0;
  repeat57: while (true) {
    r2 = (r1 + -1) | 0;
    r1 = (r0 - r1) | 0;
    heapClassInst.heap8[r1 + numDefine104] = r3;
    r1 = r2;
    if (r2 !== 0) {
      continue repeat57;
    } else {
      break repeat57;
    }
  }
  return;
}

function zn4RwL16RwExpandNameERNS14RwPodArrayIcLj256EEEPKc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg640;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = 0;
  r3 = r1;
  repeat1: while (true) {
    r4 = r2 << numDefine2;
    r5 = heapClassInst.heapU8[r3];
    if (r5 !== numDefine59) {
      if (r5 !== 0) {
        r5 = heapClassInst.heapU8[r3 + 1];
        if (r5 === numDefine59) {
          label = numDefine14;
          break repeat1;
        } else {
          if (r5 === 0) {
            label = numDefine4;
            break repeat1;
          } else {
            r5 = heapClassInst.heapU8[r3 + numDefine2];
            if (r5 !== numDefine59) {
              if (r5 === 0) {
                label = numDefine4;
                break repeat1;
              } else {
                r5 = heapClassInst.heapU8[r3 + numDefine3];
                if (r5 !== numDefine59) {
                  if (r5 === 0) {
                    label = numDefine4;
                    break repeat1;
                  } else {
                    r2 = (r2 + 1) | 0;
                    r3 = (r3 + numDefine4) | 0;
                    continue repeat1;
                  }
                } else {
                  label = numDefine11;
                  break repeat1;
                }
              }
            } else {
              label = numDefine8;
              break repeat1;
            }
          }
        }
      } else {
        label = numDefine4;
        break repeat1;
      }
    } else {
      label = numDefine2;
      break repeat1;
    }
  }
  switch (label) {
    case numDefine14:
      r2 = (r3 + 1) | 0;
      break;
    case numDefine4:
      r2 = 0;
      break;
    case numDefine2:
      r2 = (r1 + r4) | 0;
      break;
    case numDefine11:
      r2 = r4 | numDefine3;
      r2 = (r1 + r2) | 0;
      break;
    case numDefine8:
      r2 = r4 | numDefine2;
      r2 = (r1 + r2) | 0;
      break;
    default:
      break;
  }
  repeat18: do {
    if (r2 === r1) {
      r3 = (r1 + 1) | 0;
      r4 = (r1 + numDefine3) | 0;
      r5 = 0;
      r2 = r3;
      repeat20: while (true) {
        r6 = heapClassInst.heapU8[r4 + numDefineNeg2];
        if (r6 === numDefine59) {
          label = numDefine19;
          break repeat20;
        } else {
          if (r6 !== 0) {
            r6 = heapClassInst.heapU8[r4 + -1];
            if (r6 === 0) {
              label = numDefine90;
              break repeat18;
            } else {
              r7 = r5 << numDefine2;
              if (r6 !== numDefine59) {
                r6 = heapClassInst.heapU8[r4];
                if (r6 === 0) {
                  label = numDefine90;
                  break repeat18;
                } else {
                  if (r6 !== numDefine59) {
                    r6 = heapClassInst.heapU8[r4 + 1];
                    if (r6 === 0) {
                      label = numDefine90;
                      break repeat18;
                    } else {
                      if (r6 !== numDefine59) {
                        r5 = (r5 + 1) | 0;
                        r4 = (r4 + numDefine4) | 0;
                        r2 = (r2 + numDefine4) | 0;
                      } else {
                        label = numDefine27;
                        break repeat20;
                      }
                    }
                  } else {
                    label = numDefine32;
                    break repeat18;
                  }
                }
              } else {
                label = numDefine22;
                break repeat20;
              }
            }
          } else {
            label = numDefine90;
            break repeat18;
          }
        }
      }
      switch (label) {
        case numDefine19:
          r1 = r3;
          label = numDefine29;
          break repeat18;
        case numDefine27:
          r2 = r7 | numDefine3;
          r1 = (r2 + r1) | 0;
          r4 = (r1 + 1) | 0;
          label = numDefine32;
          break repeat18;
        case numDefine22:
          r2 = r7 | 1;
          r1 = (r2 + r1) | 0;
          r4 = (r1 + 1) | 0;
          label = numDefine32;
          break;
        default:
          break;
      }
    } else {
      label = numDefine29;
    }
  } while (false);
  if (label === numDefine29) {
    if (r2 === 0) {
      r3 = r1;
      label = numDefine90;
    } else {
      r4 = r2;
      r3 = r1;
      label = numDefine32;
    }
  }
  repeat39: do {
    switch (label) {
      case numDefine90:
        r7 = heapClassInst.heapU8[r3];
        if (r7 === 0) {
          r0 = sp + numDefineNeg624;
          r0 = r0 >> numDefine2;
          heapClassInst.heap32[r0 + numDefine20] = 0;
          heapClassInst.heap32[r0 + numDefine22] = 0;
          heapClassInst.heap32[r0 + numDefine21] = 0;
          label = numDefine73;
          break repeat39;
        } else {
          r7 = 1;
          label = numDefine93;
          break repeat39;
        }
      case numDefine32:
        r1 = sp + numDefineNeg264;
        r2 = sp + numDefineNeg528;
        r5 = (r1 + numDefine8) | 0;
        r6 = (r2 + numDefine8) | 0;
        r7 = 1;
        r8 = 0;
        repeat45: while (true) {
          if (r4 === 0) {
            r4 = heapClassInst.heapU8[r3];
            repeat49: do {
              if (r4 !== 0) {
                r9 = (r3 + 1) | 0;
                r10 = 0;
                while (true) {
                  r4 = (r10 + 1) | 0;
                  r11 = heapClassInst.heapU8[r9 + r10];
                  r10 = r4;
                  if (!(r11 !== 0)) {
                    break repeat49;
                  }
                }
              } else {
                r4 = 0;
              }
            } while (false);
            r4 = (r3 + r4) | 0;
          }
          r9 = (r4 - r3) | 0;
          heapClassInst.heap32[fp + numDefineNeg66] = r9;
          if (uint(r9) > uint(numDefine255)) {
            r10 = (r9 + 1) | 0;
            heapClassInst.heap32[g0] = r10;
            znaj(i7);
            r10 = commonVariable.rg0;
          } else {
            r10 = r5;
          }
          r11 = r1 >> numDefine2;
          heapClassInst.heap32[r11 + 1] = r10;
          heapClassInst.heap32[g0] = r10;
          heapClassInst.heap32[g0 + 1] = r3;
          heapClassInst.heap32[g0 + numDefine2] = r9;
          memcpy(i7);
          r9 = heapClassInst.heap32[r11 + 1];
          r10 = heapClassInst.heap32[fp + numDefineNeg66];
          r12 = 0;
          heapClassInst.heap8[r9 + r10] = r12;
          r9 = r2 >> numDefine2;
          heapClassInst.heap32[fp + numDefineNeg132] = 0;
          heapClassInst.heap32[r9 + 1] = r6;
          heapClassInst.heap8[sp + numDefineNeg520] = r12;
          r10 = zn4Rw9RwCatsE;
          r13 = (r8 * numDefine12) | 0;
          r10 = (r10 + r13) | 0;
          r13 = heapClassInst.heap32[r11 + 1];
          r10 = r10 >> numDefine2;
          r10 = heapClassInst.heap32[r10];
          heapClassInst.heap32[g0] = r10;
          heapClassInst.heap32[g0 + 1] = r13;
          heapClassInst.heap32[g0 + numDefine2] = r2;
          zn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEE(i7);
          r10 = commonVariable.rg0;
          if (r10 !== 0) {
            r13 = heapClassInst.heapU8[r10];
            repeat63: do {
              if (r13 !== 0) {
                r14 = (r10 + 1) | 0;
                while (true) {
                  r13 = (r12 + 1) | 0;
                  r15 = heapClassInst.heapU8[r14 + r12];
                  r12 = r13;
                  if (!(r15 !== 0)) {
                    break repeat63;
                  }
                }
              } else {
                r13 = 0;
              }
            } while (false);
            r12 = r7 & numDefine255;
            repeat69: do {
              if (!(r12 === 0)) {
                if (r8 !== 0) {
                  r7 = r0 >> numDefine2;
                  r7 = heapClassInst.heap32[r7 + 1];
                  r12 = r7;
                  r14 = r10;
                  r15 = r13;
                  repeat72: while (true) {
                    if (r15 !== 0) {
                      r15 = (r15 + -1) | 0;
                      r16 = (r14 + 1) | 0;
                      r17 = (r12 + 1) | 0;
                      r18 = heapClassInst.heapU8[r12];
                      r19 = heapClassInst.heapU8[r14];
                      r12 = r17;
                      r14 = r16;
                      if (r18 !== r19) {
                        label = numDefine57;
                        break repeat72;
                      } else {
                        label = numDefine54;
                      }
                    } else {
                      label = numDefine55;
                      break repeat72;
                    }
                  }
                  if (label === numDefine55) {
                    r7 = heapClassInst.heapU8[r7 + r13];
                    if (!(r7 !== numDefine59)) {
                      r7 = 1;
                      break repeat69;
                    }
                  }
                  r7 = 0;
                }
              }
            } while (false);
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r10;
            heapClassInst.heap32[g0 + numDefine2] = r13;
            zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(i7);
            r8 = (r8 + 1) | 0;
            if (r8 !== numDefine6) {
              r10 = heapClassInst.heapU8[r4];
              if (r10 !== 0) {
                r3 = twoEStr785;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r3;
                heapClassInst.heap32[g0 + numDefine2] = 1;
                zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(i7);
                r3 = (r4 + 1) | 0;
                r4 = numDefine2;
              } else {
                r4 = 1;
              }
            } else {
              r4 = 1;
              r8 = numDefine6;
            }
          } else {
            r4 = 0;
          }
          r9 = heapClassInst.heap32[r9 + 1];
          if (!(r9 === r6)) {
            if (!(r9 === 0)) {
              heapClassInst.heap32[g0] = r9;
              zdaPv(i7);
            }
          }
          if (r4 === 1) {
            label = numDefine74;
            break repeat45;
          } else {
            if (r4 !== 0) {
              r4 = heapClassInst.heap32[r11 + 1];
              if (r4 === r5) {
                label = numDefine79;
              } else {
                if (r4 !== 0) {
                  r10 = 0;
                  heapClassInst.heap32[g0] = r4;
                  zdaPv(i7);
                  r9 = r3;
                  label = numDefine81;
                } else {
                  label = numDefine79;
                }
              }
              if (label === numDefine79) {
                r10 = 0;
                r9 = r3;
              }
              repeat101: while (true) {
                r4 = r10 << numDefine2;
                r11 = r4 | numDefine3;
                r12 = r4 | numDefine2;
                r13 = heapClassInst.heapU8[r9];
                r4 = (r3 + r4) | 0;
                r11 = (r3 + r11) | 0;
                r12 = (r3 + r12) | 0;
                if (r13 === numDefine59) {
                  continue repeat45;
                } else {
                  r4 = 0;
                  if (r13 === 0) {
                    continue repeat45;
                  } else {
                    r13 = heapClassInst.heapU8[r9 + 1];
                    if (r13 === numDefine59) {
                      break repeat101;
                    } else {
                      r4 = 0;
                      if (r13 === 0) {
                        continue repeat45;
                      } else {
                        r13 = heapClassInst.heapU8[r9 + numDefine2];
                        r4 = r12;
                        if (r13 === numDefine59) {
                          continue repeat45;
                        } else {
                          r4 = 0;
                          if (r13 === 0) {
                            continue repeat45;
                          } else {
                            r12 = heapClassInst.heapU8[r9 + numDefine3];
                            r4 = r11;
                            if (r12 === numDefine59) {
                              continue repeat45;
                            } else {
                              r4 = 0;
                              if (r12 === 0) {
                                continue repeat45;
                              } else {
                                r10 = (r10 + 1) | 0;
                                r9 = (r9 + numDefine4) | 0;
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
              r4 = (r9 + 1) | 0;
              continue repeat45;
            } else {
              label = numDefine70;
              break repeat45;
            }
          }
        }
        switch (label) {
          case numDefine74:
            r1 = heapClassInst.heap32[r11 + 1];
            if (r1 === r5) {
              label = numDefine93;
              break repeat39;
            } else {
              if (r1 !== 0) {
                heapClassInst.heap32[g0] = r1;
                zdaPv(i7);
                label = numDefine93;
                break repeat39;
              } else {
                label = numDefine93;
                break repeat39;
              }
            }
          case numDefine70:
            r0 = heapClassInst.heap32[r11 + 1];
            if (r0 === r5) {
              label = numDefine73;
            } else {
              if (r0 === 0) {
                label = numDefine73;
              } else {
                heapClassInst.heap32[g0] = r0;
                zdaPv(i7);
                label = numDefine73;
              }
            }
            break;
          default:
            break;
        }
    }
  } while (false);
  repeat119: do {
    if (label === numDefine93) {
      r1 = r0 >> numDefine2;
      r2 = heapClassInst.heap32[r1 + 1];
      r4 = heapClassInst.heapU8[r2];
      if (r4 === 0) {
        heapClassInst.heap32[g0] = 0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        zn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEE(i7);
        r0 = commonVariable.rg0;
        if (r0 === 0) {
          break repeat119;
        }
      } else {
        r3 = r7 & numDefine255;
        if (!(r3 === 0)) {
          r3 = 0;
          r4 = r2;
          repeat125: while (true) {
            r5 = r3 << numDefine2;
            r6 = heapClassInst.heapU8[r4];
            if (r6 !== numDefine59) {
              if (r6 !== 0) {
                r6 = heapClassInst.heapU8[r4 + 1];
                if (r6 === numDefine59) {
                  label = numDefine109;
                  break repeat125;
                } else {
                  if (r6 === 0) {
                    label = numDefine99;
                    break repeat125;
                  } else {
                    r6 = heapClassInst.heapU8[r4 + numDefine2];
                    if (r6 !== numDefine59) {
                      if (r6 === 0) {
                        label = numDefine99;
                        break repeat125;
                      } else {
                        r6 = heapClassInst.heapU8[r4 + numDefine3];
                        if (r6 !== numDefine59) {
                          if (r6 === 0) {
                            label = numDefine99;
                            break repeat125;
                          } else {
                            r3 = (r3 + 1) | 0;
                            r4 = (r4 + numDefine4) | 0;
                          }
                        } else {
                          label = numDefine106;
                          break repeat125;
                        }
                      }
                    } else {
                      label = numDefine103;
                      break repeat125;
                    }
                  }
                }
              } else {
                label = numDefine99;
                break repeat125;
              }
            } else {
              label = numDefine97;
              break repeat125;
            }
          }
          switch (label) {
            case numDefine109:
              r3 = (r4 + 1) | 0;
              break;
            case numDefine99:
              r3 = 0;
              break;
            case numDefine97:
              r3 = (r2 + r5) | 0;
              break;
            case numDefine106:
              r3 = r5 | numDefine3;
              r3 = (r2 + r3) | 0;
              break;
            case numDefine103:
              r3 = r5 | numDefine2;
              r3 = (r2 + r3) | 0;
              break;
            default:
              break;
          }
          r3 = (r3 - r2) | 0;
          heapClassInst.heap32[r1 + 1] = r2;
          heapClassInst.heap32[r1] = r3;
          r3 = twoEStr26;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r3;
          heapClassInst.heap32[g0 + numDefine2] = 1;
          zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(i7);
        }
      }
      r0 = heapClassInst.heap32[r1 + 1];
      commonVariable.rg0 = r0;
      return;
    }
  } while (false);
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn4Rw11RwLocale9CManageEPS0PKc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg280;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  if (r0 !== 0) {
    r2 = heapClassInst.heapU8[r0];
    if (r2 === numDefine67) {
      r2 = heapClassInst.heapU8[r0 + 1];
      r3 = 0;

      r2 = r2 !== r3 ? 1 : 0;
    } else {
      r2 = 1;
    }
    r3 = sp + numDefineNeg264;
    r4 = (r3 + numDefine8) | 0;
    r5 = twoEStr538;
    r6 = r3 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg66] = 0;
    r0 = r2 !== 0 ? r0 : r5;
    r7 = 0;
    heapClassInst.heap32[r6 + 1] = r4;
    heapClassInst.heap8[sp + numDefineNeg256] = r7;
    if (r1 !== 0) {
      label = numDefine19;
    } else {
      if (r2 !== 0) {
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        zn4RwL16RwExpandNameERNS14RwPodArrayIcLj256EEEPKc(i7);
        r0 = commonVariable.rg0;
        if (r0 !== 0) {
          r2 = heapClassInst.heapU8[r0];
          if (r2 === numDefine67) {
            r2 = heapClassInst.heapU8[r0 + 1];
            if (r2 !== 0) {
              label = numDefine19;
            } else {
              r0 = r5;
              label = numDefine19;
            }
          } else {
            label = numDefine19;
          }
        } else {
          label = numDefine15;
        }
      } else {
        label = numDefine19;
      }
    }
    repeat14: do {
      if (label === numDefine19) {
        r2 = zzn4Rw11RwLocale9CManageEPS0PKcE9nLocales;
        r3 = zzn4Rw11RwLocale9CManageEPS0PKcE7locales;
        r2 = r2 >> numDefine2;
        r3 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r2];
        r8 = heapClassInst.heap32[r3];
        if (r1 === 0) {
          r7 = r5;
          repeat18: while (true) {
            r9 = r7;
            if (r9 === 0) {
              label = numDefine49;
              break repeat18;
            } else {
              r1 = r9 << 1;
              r10 = r1 & numDefineNeg4;
              r11 = (r8 + r10) | 0;
              r1 = r11 >> numDefine2;
              r1 = heapClassInst.heap32[r1];
              r12 = r1 >> numDefine2;
              r7 = heapClassInst.heap32[r12 + numDefine38];
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r7;
              strcmp(i7);
              r13 = commonVariable.rg0;
              r7 = r9 >>> 1;
              if (r13 < 0) {
                label = numDefine46;
              } else {
                if (r13 < 1) {
                  label = numDefine47;
                  break repeat18;
                } else {
                  r1 = (r10 + r8) | 0;
                  r9 = (r9 + -1) | 0;
                  r8 = (r1 + numDefine4) | 0;
                  r7 = (r9 - r7) | 0;
                }
              }
            }
          }
          if (label === numDefine47) {
            if (!(r11 === 0)) {
              r0 = heapClassInst.heap32[r12 + numDefine39];
              r0 = (r0 + 1) | 0;
              heapClassInst.heap32[r12 + numDefine39] = r0;
              label = numDefine65;
              break repeat14;
            }
          }
          r1 = zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize;
          r1 = r1 >> numDefine2;
          r7 = heapClassInst.heap32[r1];
          if (!(r5 !== r7)) {
            r5 = r5 << numDefine3;
            heapClassInst.heap32[g0] = r5;
            znaj(i7);
            r5 = commonVariable.rg0;
            r7 = heapClassInst.heap32[r3];
            r8 = heapClassInst.heap32[r2];
            r8 = r8 << numDefine2;
            heapClassInst.heap32[g0] = r5;
            heapClassInst.heap32[g0 + 1] = r7;
            heapClassInst.heap32[g0 + numDefine2] = r8;
            memcpy(i7);
            r8 = zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf;
            if (!(r7 === r8)) {
              if (!(r7 === 0)) {
                heapClassInst.heap32[g0] = r7;
                zdaPv(i7);
              }
            }
            heapClassInst.heap32[r3] = r5;
            r5 = heapClassInst.heap32[r1];
            r5 = r5 << 1;
            heapClassInst.heap32[r1] = r5;
          }
          r1 = heapClassInst.heapU8[r0];
          if (r1 !== numDefine67) {
            label = numDefine61;
          } else {
            r1 = heapClassInst.heapU8[r0 + 1];
            if (r1 !== 0) {
              label = numDefine61;
            } else {
              r1 = zzn4Rw11RwLocale9CManageEPS0PKcE7classic;
              r5 = r1 >> numDefine2;
              r1 = heapClassInst.heap32[r5];
              if (r1 !== 0) {
                r0 = zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody;
                r0 = r0 >> numDefine2;
                r5 = heapClassInst.heap32[r0 + numDefine39];
                r5 = (r5 + 1) | 0;
                heapClassInst.heap32[r0 + numDefine39] = r5;
                label = numDefine63;
              } else {
                r1 = zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                zn4Rw11RwLocaleC2EPKc(i7);
                heapClassInst.heap32[r5] = r1;
                label = numDefine63;
              }
            }
          }
          if (label === numDefine61) {
            heapClassInst.heap32[g0] = numDefine172;
            znwj(i7);
            r1 = commonVariable.rg0;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r0;
            zn4Rw11RwLocaleC2EPKc(i7);
          }
          r0 = heapClassInst.heap32[r2];
          r3 = heapClassInst.heap32[r3];
          r5 = r0 << numDefine2;
          r5 = (r3 + r5) | 0;
          r5 = r5 >> numDefine2;
          r7 = (r0 + 1) | 0;
          heapClassInst.heap32[r5] = r1;
          heapClassInst.heap32[r2] = r7;
          r2 = (r0 + -1) | 0;
          if (uint(r2) < uint(numDefine83645)) {
            r2 = swriteIndex.cmplocalesIndex;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = 0;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            heapClassInst.heap32[g0 + numDefine3] = r2;
            quicksort(i7);
            label = numDefine65;
          } else {
            label = numDefine65;
          }
        } else {
          r9 = r5;
          r10 = r8;
          repeat48: while (true) {
            r11 = r9;
            if (r11 === 0) {
              label = numDefine42;
              break repeat48;
            } else {
              r9 = r11 << 1;
              r12 = r9 & numDefineNeg4;
              r13 = (r10 + r12) | 0;
              r9 = r13 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r9 = r9 >> numDefine2;
              r9 = heapClassInst.heap32[r9 + numDefine38];
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r9;
              strcmp(i7);
              r14 = commonVariable.rg0;
              r9 = r11 >>> 1;
              if (r14 < 0) {
                label = numDefine25;
              } else {
                if (r14 < 1) {
                  label = numDefine26;
                  break repeat48;
                } else {
                  r10 = (r12 + r10) | 0;
                  r11 = (r11 + -1) | 0;
                  r10 = (r10 + numDefine4) | 0;
                  r9 = (r11 - r9) | 0;
                }
              }
            }
          }
          if (label === numDefine26) {
            if (!(r13 === 0)) {
              r1 = (r13 - r8) | 0;
              r0 = r1 & numDefineNeg4;
              r9 = (r8 + r0) | 0;
              r9 = r9 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = r9 >> numDefine2;
              r11 = heapClassInst.heap32[r10 + numDefine39];
              r11 = (r11 + -1) | 0;
              heapClassInst.heap32[r10 + numDefine39] = r11;
              if (r11 !== 0) {
                label = numDefine15;
                break repeat14;
              } else {
                r1 = r1 >> numDefine2;
                r11 = (r5 + -1) | 0;
                heapClassInst.heap32[r2] = r11;
                if (uint(r11) > uint(numDefine3)) {
                  label = numDefine33;
                } else {
                  r2 = zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf;
                  if (r8 === r2) {
                    label = numDefine33;
                  } else {
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = r0;
                    r0 = r1 << numDefine2;
                    r5 = (r0 + r8) | 0;
                    r1 = (r11 - r1) | 0;
                    memcpy(i7);
                    r0 = (r2 + r0) | 0;
                    r5 = (r5 + numDefine4) | 0;
                    r1 = r1 << numDefine2;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r5;
                    heapClassInst.heap32[g0 + numDefine2] = r1;
                    memcpy(i7);
                    if (!(r8 === 0)) {
                      heapClassInst.heap32[g0] = r8;
                      zdaPv(i7);
                    }
                    r1 = zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize;
                    r1 = r1 >> numDefine2;
                    heapClassInst.heap32[r3] = r2;
                    heapClassInst.heap32[r1] = numDefine8;
                    label = numDefine36;
                  }
                }
                repeat63: do {
                  if (label === numDefine33) {
                    r0 = (r11 - r1) | 0;
                    r0 = r0 << numDefine2;
                    if (!(r0 === 0)) {
                      r0 = r5 << numDefine2;
                      r1 = r1 << numDefine2;
                      r0 = (r0 + numDefineNeg4) | 0;
                      r2 = (r1 + r8) | 0;
                      r1 = (r0 - r1) | 0;
                      r0 = (r2 + numDefine4) | 0;
                      while (true) {
                        r2 = heapClassInst.heapU8[r0];
                        r1 = (r1 + -1) | 0;
                        r3 = (r0 + 1) | 0;
                        heapClassInst.heap8[r0 + numDefineNeg4] = r2;
                        r0 = r3;
                        if (!(r1 !== 0)) {
                          break repeat63;
                        }
                      }
                    }
                  }
                } while (false);
                r1 = heapClassInst.heap32[r10 + numDefine38];
                r0 = heapClassInst.heapU8[r1];
                if (r0 === numDefine67) {
                  r1 = heapClassInst.heapU8[r1 + 1];
                  r7 = 0;

                  r7 = r1 === r7 ? 1 : 0;
                }
                if (r7 !== 0) {
                  label = numDefine15;
                  break repeat14;
                } else {
                  if (r9 === 0) {
                    label = numDefine15;
                    break repeat14;
                  } else {
                    heapClassInst.heap32[g0] = r9;
                    zn4Rw11RwLocaleD2Ev(i7);
                    heapClassInst.heap32[g0] = r9;
                    r1 = 0;
                    zdlPv(i7);
                    label = numDefine65;
                    break repeat14;
                  }
                }
              }
            }
          }
          r0 = r1 >> numDefine2;
          r2 = heapClassInst.heap32[r0 + numDefine39];
          r1 = 0;
          r2 = (r2 + -1) | 0;
          heapClassInst.heap32[r0 + numDefine39] = r2;
          label = numDefine65;
        }
      }
    } while (false);
    if (label === numDefine15) {
      r1 = 0;
    }
    r0 = heapClassInst.heap32[r6 + 1];
    if (!(r0 === r4)) {
      if (!(r0 === 0)) {
        heapClassInst.heap32[g0] = r0;
        zdaPv(i7);
      }
    }
    commonVariable.rg0 = r1;
    return;
  } else {
    r0 = zzn4Rw11RwLocale9CManageEPS0PKcE6global;
    r0 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r0];
    repeat84: do {
      if (r2 === 0) {
        r3 = zzn4Rw11RwLocale9CManageEPS0PKcE5ginit;
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        if (r4 !== 0) {
          while (true) {
            r4 = heapClassInst.heap32[r3];
            if (!(r4 < numDefine1000)) {
              break repeat84;
            }
          }
        } else {
          r2 = (r4 + 1) | 0;
          heapClassInst.heap32[r3] = r2;
          r2 = twoEStr538;
          heapClassInst.heap32[g0] = 0;
          heapClassInst.heap32[g0 + 1] = r2;
          zn4Rw11RwLocale9CManageEPS0PKc(i7);
          r2 = commonVariable.rg0;
          heapClassInst.heap32[r0] = r2;
          r4 = heapClassInst.heap32[r3];
          r4 = (r4 + numDefine1000) | 0;
          heapClassInst.heap32[r3] = r4;
        }
      }
    } while (false);
    if (r1 === 0) {
      r0 = r2 >> numDefine2;
      r1 = heapClassInst.heap32[r0 + numDefine39];
      r1 = (r1 + 1) | 0;
      heapClassInst.heap32[r0 + numDefine39] = r1;
      commonVariable.rg0 = r2;
      return;
    } else {
      r3 = r1 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine39];
      r4 = (r4 + 1) | 0;
      heapClassInst.heap32[r3 + numDefine39] = r4;
      heapClassInst.heap32[r0] = r1;
      commonVariable.rg0 = r2;
      return;
    }
  }
}

function znst6localeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine27];
  repeat1: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + numDefine40];
      r3 = r3 & numDefine08863;
      if (!(r3 !== numDefine08863)) {
        r3 = heapClassInst.heap32[r2 + numDefine41];
        r4 = r3 & numDefine8193;
        if (!(r4 === 0)) {
          if (r4 !== numDefine8193) {
            break repeat1;
          }
        }
        r4 = r3 & numDefine49158;
        if (!(r4 === 0)) {
          if (r4 !== numDefine49158) {
            break repeat1;
          }
        }
        r4 = r3 & numDefine83160;
        if (!(r4 === 0)) {
          if (r4 !== numDefine83160) {
            break repeat1;
          }
        }
        r4 = r3 & numDefine40928;
        if (!(r4 === 0)) {
          if (r4 !== numDefine40928) {
            break repeat1;
          }
        }
        r4 = r3 & numDefine68896;
        if (!(r4 === 0)) {
          if (r4 !== numDefine68896) {
            break repeat1;
          }
        }
        r3 = r3 & numDefine58528;
        if (!(r3 === 0)) {
          if (r3 !== numDefine58528) {
            break repeat1;
          }
        }
        r3 = heapClassInst.heap32[r2 + numDefine38];
        r4 = twoEStr538;
        r5 = r3 === 0 ? r4 : r3;
        r6 = heapClassInst.heapU8[r5];
        if (r6 === numDefine59) {
          r5 = (r5 + 1) | 0;
        }
        r6 = 0;
        r7 = r6;
        repeat25: while (true) {
          r8 = heapClassInst.heapU8[r5 + r6];
          if (r8 === 0) {
            label = numDefine31;
            break repeat25;
          } else {
            r9 = (r5 + r6) | 0;
            if (r8 === numDefine59) {
              label = numDefine28;
              break repeat25;
            } else {
              r8 = heapClassInst.heapU8[r9 + 1];
              if (r8 === 0) {
                label = numDefine31;
                break repeat25;
              } else {
                if (r8 === numDefine59) {
                  label = numDefine29;
                  break repeat25;
                } else {
                  r8 = heapClassInst.heapU8[r9 + numDefine2];
                  if (r8 === 0) {
                    label = numDefine31;
                    break repeat25;
                  } else {
                    r10 = r7 << numDefine2;
                    if (r8 !== numDefine59) {
                      r9 = heapClassInst.heapU8[r9 + numDefine3];
                      if (r9 === 0) {
                        label = numDefine31;
                        break repeat25;
                      } else {
                        if (r9 !== numDefine59) {
                          r7 = (r7 + 1) | 0;
                          r6 = (r6 + numDefine4) | 0;
                        } else {
                          label = numDefine26;
                          break repeat25;
                        }
                      }
                    } else {
                      label = numDefine23;
                      break repeat25;
                    }
                  }
                }
              }
            }
          }
        }
        repeat35: do {
          switch (label) {
            case numDefine28:
              if (r9 === 0) {
                label = numDefine31;
                break repeat35;
              } else {
                label = numDefine30;
                break repeat35;
              }
            case numDefine29:
              r9 = (r9 + 1) | 0;
              label = numDefine30;
              break repeat35;
            case numDefine26:
              r6 = r10 | numDefine3;
              r9 = (r5 + r6) | 0;
              label = numDefine30;
              break repeat35;
            case numDefine23:
              r6 = r10 | numDefine2;
              r9 = (r5 + r6) | 0;
              label = numDefine30;
              break;
            default:
              break;
          }
        } while (false);
        switch (label) {
          case numDefine31:
            r6 = heapClassInst.heapU8[r5];
            if (r6 !== 0) {
              r7 = (r5 + 1) | 0;
              r8 = 0;
              repeat44: while (true) {
                r6 = (r8 + 1) | 0;
                r9 = heapClassInst.heapU8[r7 + r8];
                r8 = r6;
                if (!(r9 !== 0)) {
                  break repeat44;
                }
              }
              r9 = 0;
              r7 = r9;
              r8 = r9;
            } else {
              r9 = 0;
              r6 = r9;
              r7 = r9;
              r8 = r9;
            }
            break;
          case numDefine30:
            r6 = (r9 - r5) | 0;
            r7 = 0;
            r8 = r7;
            break;
          default:
            break;
        }
        repeat49: while (true) {
          if (r7 !== numDefine26) {
            r10 = r7 << numDefine2;
            r10 = (r1 + r10) | 0;
            r10 = r10 >> numDefine2;
            r10 = heapClassInst.heap32[r10];
            repeat52: do {
              if (r10 !== 0) {
                r10 = r10 >> numDefine2;
                r11 = heapClassInst.heap32[r10 + numDefine7];
                r11 = r11 >> numDefine2;
                r10 = heapClassInst.heap32[r10 + 1];
                r12 = 0;

                r13 = r10 !== r12 ? 1 : 0;
                r11 = heapClassInst.heap32[r11];
                r13 = r13 & 1;
                r11 = r11 << 1;
                r11 = r13 | r11;
                r11 = (r11 + -1) | 0;
                r13 = numDefine53;
                r11 = uint(r11) < uint(r13) ? r11 : r12;
                if (r11 > numDefine36) {
                  r11 = (r11 + numDefineNeg37) | 0;
                  if (!(uint(r11) > uint(numDefine8))) {
                    r13 = 1;
                    r11 = r13 << r11;
                    r11 = r11 & numDefine325;
                    if (r11 !== 0) {
                      break repeat52;
                    }
                  }
                } else {
                  if (!(uint(r11) > uint(numDefine19))) {
                    r13 = 1;
                    r11 = r13 << r11;
                    r11 = r11 & numDefine65600;
                    if (r11 !== 0) {
                      break repeat52;
                    }
                  }
                }
                r11 = 1;
                r11 = r11 << r7;
                repeat60: while (true) {
                  if (r9 === 0) {
                    break repeat60;
                  } else {
                    r13 = zn4Rw9RwCatsE;
                    r14 = (r8 * numDefine12) | 0;
                    r13 = (r13 + r14) | 0;
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13 + numDefine2];
                    r13 = r13 & r11;
                    if (r13 === 0) {
                      r5 = heapClassInst.heapU8[r9];
                      if (r5 === 0) {
                        if (r3 !== 0) {
                          r8 = 0;
                          r5 = r3;
                        } else {
                          r8 = 0;
                          r5 = r4;
                        }
                      } else {
                        r5 = (r9 + 1) | 0;
                        r8 = (r8 + 1) | 0;
                      }
                      r6 = heapClassInst.heapU8[r5];
                      if (r6 === numDefine59) {
                        r5 = (r5 + 1) | 0;
                      }
                      r6 = r12;
                      r13 = r12;
                      repeat74: while (true) {
                        r14 = heapClassInst.heapU8[r5 + r6];
                        if (r14 === 0) {
                          label = numDefine65;
                          break repeat74;
                        } else {
                          r9 = (r5 + r6) | 0;
                          if (r14 === numDefine59) {
                            label = numDefine62;
                            break repeat74;
                          } else {
                            r14 = heapClassInst.heapU8[r9 + 1];
                            if (r14 === 0) {
                              label = numDefine65;
                              break repeat74;
                            } else {
                              if (r14 === numDefine59) {
                                label = numDefine63;
                                break repeat74;
                              } else {
                                r14 = heapClassInst.heapU8[r9 + numDefine2];
                                if (r14 === 0) {
                                  label = numDefine65;
                                  break repeat74;
                                } else {
                                  r15 = r13 << numDefine2;
                                  if (r14 !== numDefine59) {
                                    r9 = heapClassInst.heapU8[r9 + numDefine3];
                                    if (r9 === 0) {
                                      label = numDefine65;
                                      break repeat74;
                                    } else {
                                      if (r9 !== numDefine59) {
                                        r13 = (r13 + 1) | 0;
                                        r6 = (r6 + numDefine4) | 0;
                                      } else {
                                        label = numDefine60;
                                        break repeat74;
                                      }
                                    }
                                  } else {
                                    label = numDefine57;
                                    break repeat74;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                      repeat84: do {
                        switch (label) {
                          case numDefine62:
                            if (r9 === 0) {
                              label = numDefine65;
                              break repeat84;
                            } else {
                              label = numDefine64;
                              break repeat84;
                            }
                          case numDefine63:
                            r9 = (r9 + 1) | 0;
                            label = numDefine64;
                            break repeat84;
                          case numDefine60:
                            r6 = r15 | numDefine3;
                            r9 = (r5 + r6) | 0;
                            label = numDefine64;
                            break repeat84;
                          case numDefine57:
                            r6 = r15 | numDefine2;
                            r9 = (r5 + r6) | 0;
                            label = numDefine64;
                            break;
                          default:
                            break;
                        }
                      } while (false);
                      switch (label) {
                        case numDefine65:
                          r9 = twoEStr26;
                          r6 = 0;
                          r13 = heapClassInst.heapU8[r5];
                          if (r13 === 0) {
                            continue repeat60;
                          } else {
                            r13 = (r5 + 1) | 0;
                            r14 = 0;
                            while (true) {
                              r6 = (r14 + 1) | 0;
                              r9 = twoEStr26;
                              r15 = heapClassInst.heapU8[r13 + r14];
                              r14 = r6;
                              if (!(r15 !== 0)) {
                                continue repeat60;
                              }
                            }
                          }
                        case numDefine64:
                          r6 = (r9 - r5) | 0;
                          break;
                        default:
                          break;
                      }
                    } else {
                      break repeat60;
                    }
                  }
                }
                r11 = twoEStr538;
                r10 = r10 === 0 ? r11 : r10;
                r11 = heapClassInst.heapU8[r10];
                repeat96: do {
                  if (r11 !== 0) {
                    r12 = (r10 + 1) | 0;
                    r13 = 0;
                    while (true) {
                      r11 = (r13 + 1) | 0;
                      r14 = heapClassInst.heapU8[r12 + r13];
                      r13 = r11;
                      if (!(r14 !== 0)) {
                        break repeat96;
                      }
                    }
                  } else {
                    r11 = 0;
                  }
                } while (false);
                if (r11 !== r6) {
                  break repeat1;
                } else {
                  r11 = 0;
                  while (true) {
                    r12 = (r6 + r11) | 0;
                    if (r12 !== 0) {
                      r12 = (r5 - r11) | 0;
                      r13 = (r10 - r11) | 0;
                      r11 = (r11 + -1) | 0;
                      r12 = heapClassInst.heapU8[r12];
                      r13 = heapClassInst.heapU8[r13];
                      if (r12 !== r13) {
                        break repeat1;
                      }
                    } else {
                      break repeat52;
                    }
                  }
                }
              }
            } while (false);
            r7 = (r7 + 1) | 0;
          } else {
            break repeat49;
          }
        }
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r3;
        zn4Rw11RwLocale9CManageEPS0PKc(i7);
        return;
      }
    }
  } while (false);
  r1 = heapClassInst.heap32[r2 + numDefine39];
  r1 = (r1 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine39] = r1;
  if (!(r1 !== 0)) {
    r0 = heapClassInst.heap32[r0];
    if (!(r0 === 0)) {
      heapClassInst.heap32[g0] = r0;
      zn4Rw11RwLocaleD2Ev(i7);
      heapClassInst.heap32[g0] = r0;
      zdlPv(i7);
    }
  }
  return;
}

function zn4Rw10RwThrowEiz(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg64;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (r0 > numDefine4) {
    r1 = (sp + numDefine4) | 0;
    heapClassInst.heap32[fp + numDefineNeg7] = r1;
    r2 = zzn4RwL13RwVfmtwhatEPcjiS0E7Fname;
    heapClassInst.heap32[fp + numDefineNeg9] = r1;
    r2 = r2 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg8] = r1;
    r3 = heapClassInst.heap32[r2];
    if (!(r3 !== 0)) {
      r3 = zzn4RwL13RwVfmtwhatEPcjiS0E6buffer;
      r4 = 0;
      repeat5: while (true) {
        r5 = heapClassInst.heapU8[r3];
        r4 = r5 === numDefine58 ? r3 : r4;
        if (r5 !== 0) {
          r5 = (r3 + 1) | 0;
          r6 = heapClassInst.heapU8[r3 + 1];
          r4 = r6 === numDefine58 ? r5 : r4;
          if (r6 !== 0) {
            r5 = (r3 + numDefine2) | 0;
            r6 = heapClassInst.heapU8[r3 + numDefine2];
            r4 = r6 === numDefine58 ? r5 : r4;
            if (r6 !== 0) {
              r5 = (r3 + numDefine3) | 0;
              r6 = heapClassInst.heapU8[r3 + numDefine3];
              r4 = r6 === numDefine58 ? r5 : r4;
              if (r6 !== 0) {
                r3 = (r3 + numDefine4) | 0;
              } else {
                break repeat5;
              }
            } else {
              break repeat5;
            }
          } else {
            break repeat5;
          }
        } else {
          break repeat5;
        }
      }
      repeat12: do {
        if (!(r4 === 0)) {
          r3 = 0;
          heapClassInst.heap8[r4] = r3;
          r3 = zzn4RwL13RwVfmtwhatEPcjiS0E8Catset;
          r4 = (r4 + 1) | 0;
          heapClassInst.heap32[g0] = r4;
          heapClassInst.heap32[g0 + 1] = r3;
          sscanf(i7);
          r4 = commonVariable.rg0;
          r3 = r3 >> numDefine2;
          if (!(r4 !== 1)) {
            r4 = heapClassInst.heap32[r3];
            if (r4 > 0) {
              break repeat12;
            }
          }
          heapClassInst.heap32[r3] = 1;
        }
      } while (false);
      r3 = zzn4RwL13RwVfmtwhatEPcjiS0E4msgs;
      r4 = r3 >> numDefine2;
      heapClassInst.heap32[r4 + 1] = 0;
      heapClassInst.heap32[r4 + numDefine2] = 0;
      heapClassInst.heap32[r4 + numDefine3] = 0;
      heapClassInst.heap32[r4 + numDefine4] = 0;
      heapClassInst.heap32[r4 + numDefine5] = 0;
      r5 = ztvst8messagesIcE;
      heapClassInst.heap32[r4 + numDefine6] = 0;
      r5 = (r5 + numDefine8) | 0;
      heapClassInst.heap32[r4 + numDefine7] = 0;
      r6 = zn4RwL22RwClassicOnceInitE2E02EB;
      heapClassInst.heap32[r4] = r5;
      r5 = heapClassInst.heapU8[r6];
      if (!(r5 !== 0)) {
        zn4Rw11RwLocale11CGetBodyEPS0S1PKciPKNS10RwFacetE(i7);
        r5 = commonVariable.rg0;
        r7 = zn4RwL12RwClassicE;
        r7 = r7 >> numDefine2;
        heapClassInst.heap32[r7] = r5;
        if (!(r5 !== 0)) {
          r5 = twoEStr12102177;
          r7 = twoEStr10100175;
          r8 = twoEStr538;
          heapClassInst.heap32[g0] = numDefine19;
          heapClassInst.heap32[g0 + 1] = r5;
          heapClassInst.heap32[g0 + numDefine2] = r7;
          heapClassInst.heap32[g0 + numDefine3] = r8;
          zn4Rw10RwThrowEiz(i7);
        }
        r5 = 1;
        heapClassInst.heap8[r6] = r5;
      }
      r5 = zzn4RwL13RwVfmtwhatEPcjiS0E6buffer;
      r6 = heapClassInst.heapU8[r5];
      if (r6 === 0) {
        r6 = znss11CNullRefE;
        r7 = 0;
        r6 = (r6 + numDefine12) | 0;
      } else {
        r6 = 0;
        repeat28: while (true) {
          r7 = (r5 - r6) | 0;
          r6 = (r6 + -1) | 0;
          r7 = heapClassInst.heapU8[r7 + 1];
          if (!(r7 !== 0)) {
            break repeat28;
          }
        }
        r7 = 0;
        r7 = (r7 - r6) | 0;
        if (r6 !== 0) {
          r6 = numDefine32;
          r6 = uint(r7) > uint(r6) ? r7 : r6;
          heapClassInst.heap32[g0] = r6;
          heapClassInst.heap32[g0 + 1] = r7;
          znss10CGetRepEjj(i7);
          r6 = (commonVariable.rg0 + numDefine12) | 0;
        } else {
          r6 = znss11CNullRefE;
          r6 = (r6 + numDefine12) | 0;
        }
      }
      heapClassInst.heap32[fp + numDefineNeg4] = r6;
      heapClassInst.heap32[g0] = r6;
      heapClassInst.heap32[g0 + 1] = r5;
      heapClassInst.heap32[g0 + numDefine2] = r7;
      memcpy(i7);
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine2];
      r6 = sp + numDefineNeg16;
      r7 = zn4RwL12RwClassicE;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r6;
      heapClassInst.heap32[g0 + numDefine2] = r7;
      functionTable[r4 >> numDefine2](i7);
      r3 = commonVariable.rg0;
      r4 = zzn4RwL13RwVfmtwhatEPcjiS0E5Cat;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r4] = r3;
      r3 = heapClassInst.heap32[fp + numDefineNeg4];
      r3 = (r3 + numDefineNeg12) | 0;
      r4 = znss11CNullRefE;
      if (!(r3 === r4)) {
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        r6 = (r4 + -1) | 0;
        heapClassInst.heap32[r3] = r6;
        if (!(r4 > 0)) {
          r3 = heapClassInst.heap32[fp + numDefineNeg4];
          r3 = (r3 + numDefineNeg12) | 0;
          heapClassInst.heap32[g0] = r3;
          zdlPv(i7);
        }
      }
      heapClassInst.heap32[fp + numDefineNeg4] = 0;
      heapClassInst.heap32[r2] = r5;
    }
    r2 = zzn4RwL13RwVfmtwhatEPcjiS0E5Cat;
    r2 = r2 >> numDefine2;
    r2 = heapClassInst.heap32[r2];
    if (r2 !== -1) {
      r3 = znss11CNullRefE;
      r4 = zzn4RwL13RwVfmtwhatEPcjiS0E4msgs;
      r5 = (r3 + numDefine12) | 0;
      r6 = r4 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg2] = r5;
      r5 = zzn4RwL13RwVfmtwhatEPcjiS0E8Catset;
      r6 = heapClassInst.heap32[r6];
      r6 = r6 >> numDefine2;
      r5 = r5 >> numDefine2;
      r6 = heapClassInst.heap32[r6 + numDefine3];
      r5 = heapClassInst.heap32[r5];
      r7 = sp + numDefineNeg24;
      r8 = sp + numDefineNeg8;
      heapClassInst.heap32[g0] = r7;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r2;
      heapClassInst.heap32[g0 + numDefine3] = r5;
      heapClassInst.heap32[g0 + numDefine4] = r0;
      heapClassInst.heap32[g0 + numDefine5] = r8;
      functionTable[r6 >> numDefine2](i7);
      r2 = heapClassInst.heap32[fp + numDefineNeg2];
      r2 = (r2 + numDefineNeg12) | 0;
      if (!(r2 === r3)) {
        r2 = r2 >> numDefine2;
        r4 = heapClassInst.heap32[r2];
        r5 = (r4 + -1) | 0;
        heapClassInst.heap32[r2] = r5;
        if (!(r4 > 0)) {
          r2 = heapClassInst.heap32[fp + numDefineNeg2];
          r2 = (r2 + numDefineNeg12) | 0;
          heapClassInst.heap32[g0] = r2;
          zdlPv(i7);
        }
      }
      heapClassInst.heap32[fp + numDefineNeg2] = 0;
      r2 = heapClassInst.heap32[fp + numDefineNeg6];
      r4 = r2 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + -1];
      if (r4 !== 0) {
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r1;
        zn4RwL13RwVfmtwhatEPcjPKcS0(i7);
        r1 = commonVariable.rg0;
        r2 = heapClassInst.heap32[fp + numDefineNeg6];
      } else {
        r1 = 0;
      }
      r2 = (r2 + numDefineNeg12) | 0;
      if (!(r2 === r3)) {
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r2];
        r4 = (r3 + -1) | 0;
        heapClassInst.heap32[r2] = r4;
        if (!(r3 > 0)) {
          r2 = heapClassInst.heap32[fp + numDefineNeg6];
          r2 = (r2 + numDefineNeg12) | 0;
          heapClassInst.heap32[g0] = r2;
          zdlPv(i7);
        }
      }
      heapClassInst.heap32[fp + numDefineNeg6] = 0;
      if (r1 === 0) {
        label = numDefine50;
      } else {
        label = numDefine51;
      }
    } else {
      label = numDefine50;
    }
    if (label === numDefine50) {
      r1 = numDefine24;
      r2 = 0;
      r0 = uint(r0) > uint(r1) ? r2 : r0;
      r1 = zzn4Rw10RwThrowEizE6errors;
      r2 = r0 << numDefine2;
      r1 = (r1 + r2) | 0;
      r1 = r1 >> numDefine2;
      r2 = heapClassInst.heap32[fp + numDefineNeg7];
      r1 = heapClassInst.heap32[r1];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r2;
      zn4RwL13RwVfmtwhatEPcjPKcS0(i7);
      r1 = commonVariable.rg0;
      if (r1 === 0) {
        if (r0 === numDefine2) {
          r0 = twoEStr47;
        } else {
          if (r0 === 1) {
            r0 = twoEStr15132;
          } else {
            if (r0 !== 0) {
              r0 = twoEStr5134;
            } else {
              r0 = twoEStr4131;
            }
          }
        }
        heapClassInst.heap32[g0] = r0;
        fprintf(i7);
        label = numDefine62;
      } else {
        label = numDefine51;
      }
    }
    if (label === numDefine51) {
      heapClassInst.heap32[g0] = r1;
      r0 = zn4RwL13RwWhatBufE;
      fprintf(i7);
      if (r1 !== r0) {
        heapClassInst.heap32[g0] = r1;
        zdaPv(i7);
      } else {
        r0 = zn4RwL16RwWhatRefcntE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r1 = (r1 + -1) | 0;
        heapClassInst.heap32[r0] = r1;
      }
    }
    abort(i7);
  } else {
    if (r0 === numDefine2) {
      r0 = twoEStr47;
    } else {
      if (r0 === 1) {
        r0 = twoEStr15132;
      } else {
        if (r0 !== 0) {
          r0 = twoEStr5134;
        } else {
          r0 = twoEStr4131;
        }
      }
    }
    heapClassInst.heap32[g0] = r0;
    fprintf(i7);
    abort(i7);
  }
}

function zn4RwL20RwManageCatDataERiPNS18RwOpenCatDataE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE4init2EB;
  r1 = heapClassInst.heapU8[r0];
  if (!(r1 !== 0)) {
    r1 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize;
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    if (!(r1 === 0)) {
      r2 = 0;
      repeat5: while (true) {
        r3 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs;
        r3 = r3 >> numDefine2;
        r4 = r2 << numDefine3;
        r3 = heapClassInst.heap32[r3];
        r3 = (r3 + r4) | 0;
        r2 = (r2 + 1) | 0;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r3] = -1;
        if (!(uint(r2) < uint(r1))) {
          break repeat5;
        }
      }
    }
    r1 = 1;
    heapClassInst.heap8[r0] = r1;
  }
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r0];
  repeat9: do {
    if (r2 !== -1) {
      if (r1 !== 0) {
        r3 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs;
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        r5 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs;
        r4 = (r4 + -1) | 0;
        r5 = r5 >> numDefine2;
        heapClassInst.heap32[r3] = r4;
        r3 = heapClassInst.heap32[r5];
        r2 = r2 << numDefine3;
        r2 = (r3 + r2) | 0;
        r4 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r2] = -1;
        r2 = r4 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r4 = heapClassInst.heap32[r2];
        if (r0 === r4) {
          label = numDefine33;
          repeat13: while (true) {
            if (r0 > -1) {
              r6 = r0 << numDefine3;
              r6 = (r3 + r6) | 0;
              r6 = r6 >> numDefine2;
              r6 = heapClassInst.heap32[r6];
              if (r6 === -1) {
                r0 = (r0 + -1) | 0;
              } else {
                label = numDefine31;
                break repeat13;
              }
            } else {
              label = numDefine34;
              break repeat13;
            }
          }
          switch (label) {
            case numDefine34:
              r0 = r4;
              break;
            case numDefine31:
              heapClassInst.heap32[r2] = r0;
              break;
            default:
              break;
          }
          if (uint(r0) > uint(numDefine3)) {
            label = numDefine40;
            break repeat9;
          } else {
            r0 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf;
            if (r3 === r0) {
              label = numDefine40;
              break repeat9;
            } else {
              r2 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize;
              r2 = r2 >> numDefine2;
              heapClassInst.heap32[r2] = numDefine8;
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r3;
              heapClassInst.heap32[g0 + numDefine2] = numDefine64;
              memcpy(i7);
              if (!(r3 === 0)) {
                heapClassInst.heap32[g0] = r3;
                zdaPv(i7);
              }
              heapClassInst.heap32[r5] = r0;
              label = numDefine40;
              break repeat9;
            }
          }
        } else {
          label = numDefine40;
          break repeat9;
        }
      } else {
        r0 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize;
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        if (uint(r2) >= uint(r0)) {
          label = numDefine7;
          break repeat9;
        } else {
          r0 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs;
          r0 = r0 >> numDefine2;
          r0 = heapClassInst.heap32[r0];
          r1 = r2 << numDefine3;
          r0 = (r0 + r1) | 0;
          commonVariable.rg0 = r0;
          return;
        }
      }
    } else {
      if (r1 !== 0) {
        r2 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs;
        r2 = r2 >> numDefine2;
        r3 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize;
        r4 = heapClassInst.heap32[r2];
        r3 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r3];
        if (r4 === r5) {
          r4 = r4 << numDefine4;
          r5 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs;
          heapClassInst.heap32[g0] = r4;
          znaj(i7);
          r4 = commonVariable.rg0;
          r5 = r5 >> numDefine2;
          r6 = heapClassInst.heap32[r2];
          r7 = heapClassInst.heap32[r5];
          r8 = r6 << numDefine3;
          heapClassInst.heap32[g0] = r4;
          heapClassInst.heap32[g0 + 1] = r7;
          heapClassInst.heap32[g0 + numDefine2] = r8;
          memcpy(i7);
          r8 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf;
          if (!(r7 === r8)) {
            if (r7 !== 0) {
              heapClassInst.heap32[g0] = r7;
              zdaPv(i7);
              r6 = heapClassInst.heap32[r2];
            }
          }
          heapClassInst.heap32[r5] = r4;
          r5 = heapClassInst.heap32[r3];
          r5 = r5 << 1;
          heapClassInst.heap32[r3] = r5;
          repeat36: do {
            if (!(uint(r6) >= uint(r5))) {
              r3 = (r6 + 1) | 0;
              while (true) {
                r7 = r3 << numDefine3;
                r7 = (r4 + r7) | 0;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7 + numDefineNeg2] = -1;
                if (uint(r3) >= uint(r5)) {
                  break repeat36;
                } else {
                  r3 = (r3 + 1) | 0;
                }
              }
            }
          } while (false);
          r3 = r6 << numDefine3;
          r3 = (r4 + r3) | 0;
          heapClassInst.heap32[r0] = r6;
          r3 = (r3 + numDefine4) | 0;
          r5 = (r1 + numDefine4) | 0;
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r5;
          heapClassInst.heap32[g0 + numDefine2] = numDefine4;
          memcpy(i7);
          r3 = heapClassInst.heap32[r0];
          r3 = r3 << numDefine3;
          r5 = r1 >> numDefine2;
          r3 = (r4 + r3) | 0;
          r4 = heapClassInst.heap32[r5];
          r3 = r3 >> numDefine2;
          heapClassInst.heap32[r3] = r4;
          r0 = heapClassInst.heap32[r0];
          r3 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat;
          r3 = r3 >> numDefine2;
          r4 = heapClassInst.heap32[r3];
          if (!(uint(r0) <= uint(r4))) {
            heapClassInst.heap32[r3] = r0;
          }
          r0 = (r6 + 1) | 0;
          heapClassInst.heap32[r2] = r0;
          commonVariable.rg0 = r1;
          return;
        } else {
          r3 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs;
          r3 = r3 >> numDefine2;
          heapClassInst.heap32[r0] = 0;
          r3 = heapClassInst.heap32[r3];
          r5 = r3 >> numDefine2;
          r5 = heapClassInst.heap32[r5];
          repeat46: do {
            if (r5 !== -1) {
              r5 = 0;
              while (true) {
                r6 = r5 << numDefine3;
                r6 = (r3 + r6) | 0;
                r5 = (r5 + 1) | 0;
                r6 = r6 >> numDefine2;
                heapClassInst.heap32[r0] = r5;
                r6 = heapClassInst.heap32[r6 + numDefine2];
                if (!(r6 !== -1)) {
                  break repeat46;
                }
              }
            } else {
              r5 = 0;
            }
          } while (false);
          r6 = zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat;
          r6 = r6 >> numDefine2;
          r7 = heapClassInst.heap32[r6];
          if (!(uint(r5) <= uint(r7))) {
            heapClassInst.heap32[r6] = r5;
          }
          r5 = r5 << numDefine3;
          r5 = (r3 + r5) | 0;
          r5 = (r5 + numDefine4) | 0;
          r6 = (r1 + numDefine4) | 0;
          heapClassInst.heap32[g0] = r5;
          heapClassInst.heap32[g0 + 1] = r6;
          heapClassInst.heap32[g0 + numDefine2] = numDefine4;
          memcpy(i7);
          r0 = heapClassInst.heap32[r0];
          r0 = r0 << numDefine3;
          r5 = r1 >> numDefine2;
          r0 = (r3 + r0) | 0;
          r3 = heapClassInst.heap32[r5];
          r0 = r0 >> numDefine2;
          r4 = (r4 + 1) | 0;
          heapClassInst.heap32[r0] = r3;
          heapClassInst.heap32[r2] = r4;
          commonVariable.rg0 = r1;
          return;
        }
      } else {
        label = numDefine7;
      }
    }
  } while (false);
  if (label === numDefine7) {
    r1 = 0;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn4Rw14RwCatCloseEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  heapClassInst.heap32[fp + -1] = r0;
  if (!(r0 < 0)) {
    r0 = sp + numDefineNeg4;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = 0;
    zn4RwL20RwManageCatDataERiPNS18RwOpenCatDataE(i7);
    r1 = commonVariable.rg0;
    if (!(r1 === 0)) {
      r2 = r1 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      if (!(r2 === -1)) {
        r3 = zn4RwL12RwCatlistE2E1;
        r4 = zn4RwL12RwCatlistE2E0;
        r3 = r3 >> numDefine2;
        r4 = r4 >> numDefine2;
        r5 = heapClassInst.heap32[r4];
        r6 = heapClassInst.heap32[r3];
        r6 = (r6 - r5) | 0;
        r6 = r6 >> numDefine2;
        r7 = 0;
        repeat5: while (true) {
          if (uint(r6) > uint(r7)) {
            r8 = r7 << numDefine2;
            r8 = (r5 + r8) | 0;
            r8 = r8 >> numDefine2;
            r8 = heapClassInst.heap32[r8];
            if (r8 === 0) {
              label = numDefine7;
              break repeat5;
            } else {
              if (r8 !== r2) {
                r7 = (r7 + 1) | 0;
              } else {
                label = numDefine9;
                break repeat5;
              }
            }
          } else {
            label = numDefine7;
            break repeat5;
          }
        }
        if (label === numDefine7) {
          r7 = r6;
        }
        repeat13: do {
          if (!(uint(r6) <= uint(r7))) {
            r2 = r7 << numDefine2;
            r6 = (r5 + r2) | 0;
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            if (r6 !== 0) {
              heapClassInst.heap32[g0] = r6;
              zdlPv(i7);
              r5 = heapClassInst.heap32[r4];
            }
            r2 = (r5 + r2) | 0;
            r4 = (r7 + 1) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = 0;
            repeat18: while (true) {
              r2 = heapClassInst.heap32[r3];
              r2 = (r2 - r5) | 0;
              r2 = r2 >> numDefine2;
              if (uint(r2) <= uint(r4)) {
                break repeat13;
              } else {
                r2 = r4 << numDefine2;
                r2 = (r5 + r2) | 0;
                r6 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r6];
                if (r2 !== 0) {
                  r4 = (r4 + 1) | 0;
                  heapClassInst.heap32[r6 + -1] = r2;
                } else {
                  break repeat18;
                }
              }
            }
            heapClassInst.heap32[r6] = 0;
          }
        } while (false);
        r2 = (r1 + numDefine4) | 0;
        heapClassInst.heap32[g0] = r2;
        znst6localeD1Ev(i7);
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        zn4RwL20RwManageCatDataERiPNS18RwOpenCatDataE(i7);
        return;
      }
    }
  }
  r0 = twoEStr115180;
  r1 = twoEStr1116181;
  heapClassInst.heap32[g0] = numDefine7;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  zn4Rw10RwThrowEiz(i7);
  return;
}

function zn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg368;
  let g0 = i7 >> numDefine2;
  r0 = zzn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEEE11localeRoot;
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heapU8[r0];
  r5 = 0;
  heapClassInst.heap8[sp + numDefineNeg259] = r5;
  r6 = heapClassInst.heapU8[r2];
  repeat1: do {
    if (r6 !== 0) {
      r7 = (r2 + 1) | 0;
      repeat3: while (true) {
        r6 = (r5 + 1) | 0;
        r8 = heapClassInst.heapU8[r7 + r5];
        r5 = r6;
        if (r8 !== 0) {
          continue repeat3;
        } else {
          break repeat1;
        }
      }
    } else {
      r6 = 0;
    }
  } while (false);
  r4 = r4 & numDefine255;
  repeat7: do {
    if (r4 !== 0) {
      r4 = (r6 + 1) | 0;
      r5 = (r0 + 1) | 0;
      repeat9: while (true) {
        r4 = (r4 + 1) | 0;
        r7 = (r5 + 1) | 0;
        r8 = heapClassInst.heapU8[r5];
        r5 = r7;
        if (!(r8 !== 0)) {
          break repeat9;
        }
      }
      if (uint(r4) > uint(numDefine258)) {
        label = numDefine5;
      } else {
        r4 = sp + numDefineNeg259;
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r0;
        strcpy(i7);
        r0 = heapClassInst.heapU8[sp + numDefineNeg259];
        repeat13: do {
          if (r0 !== 0) {
            r0 = (r4 + 1) | 0;
            r7 = 0;
            while (true) {
              r5 = (r7 + 1) | 0;
              r8 = heapClassInst.heapU8[r0 + r7];
              r7 = r5;
              if (!(r8 !== 0)) {
                break repeat13;
              }
            }
          } else {
            r5 = 0;
          }
        } while (false);
        r7 = numDefine47;
        r0 = (r5 + 1) | 0;
        r8 = 0;
        heapClassInst.heap8[r4 + r5] = r7;
        heapClassInst.heap8[r4 + r0] = r8;
        r5 = heapClassInst.heapU8[sp + numDefineNeg259];
        if (r5 !== 0) {
          r5 = (r4 + 1) | 0;
          repeat21: while (true) {
            r4 = (r8 + 1) | 0;
            r7 = heapClassInst.heapU8[r5 + r8];
            r8 = r4;
            if (r7 !== 0) {
              continue repeat21;
            } else {
              label = numDefine17;
              break repeat7;
            }
          }
        } else {
          r4 = 0;
          label = numDefine17;
        }
      }
    } else {
      label = numDefine5;
    }
  } while (false);
  if (label === numDefine5) {
    r0 = 0;
    r4 = r0;
  }
  r4 = (r4 + r6) | 0;
  if (!(uint(r4) > uint(numDefine258))) {
    r4 = sp + numDefineNeg259;
    r0 = (r4 + r0) | 0;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    strcpy(i7);
    r0 = twoEStr37683;
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r0;
    strcmp(i7);
    r0 = commonVariable.rg0;
    if (r0 === 0) {
      r1 = heapClassInst.heapU8[r2];
      repeat31: do {
        if (r1 !== 0) {
          r0 = (r2 + 1) | 0;
          r4 = 0;
          while (true) {
            r1 = (r4 + 1) | 0;
            r5 = heapClassInst.heapU8[r0 + r4];
            r4 = r1;
            if (!(r5 !== 0)) {
              break repeat31;
            }
          }
        } else {
          r1 = 0;
        }
      } while (false);
      r0 = r3 >> numDefine2;
      heapClassInst.heap32[r0] = 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r2;
      heapClassInst.heap32[g0 + numDefine2] = r1;
      zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(i7);
      r1 = heapClassInst.heap32[r0 + 1];
      commonVariable.rg0 = r1;
      return;
    } else {
      r2 = twoEStr1648;
      heapClassInst.heap32[g0] = r4;
      heapClassInst.heap32[g0 + 1] = r2;
      fopen(i7);
      r2 = commonVariable.rg0;
      if (!(r2 === 0)) {
        if (uint(r2) < uint(numDefine10)) {
          r3 = zl13sFileStdout;
          r0 = r3 >> numDefine2;
          r0 = heapClassInst.heap32[r0];
          r0 = r0 >> numDefine2;
          r0 = heapClassInst.heap32[r0 + numDefine7];
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = 0;
          heapClassInst.heap32[g0 + numDefine2] = numDefine2;
          functionTable[r0 >> numDefine2](i7);
        } else {
          r3 = r2 >> numDefine2;
          r3 = heapClassInst.heap32[r3];
          r3 = r3 >> numDefine2;
          r3 = heapClassInst.heap32[r3 + numDefine7];
          heapClassInst.heap32[g0] = r2;
          heapClassInst.heap32[g0 + 1] = 0;
          heapClassInst.heap32[g0 + numDefine2] = numDefine2;
          functionTable[r3 >> numDefine2](i7);
          r3 = r2;
        }
        r0 = r3 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine5];
        heapClassInst.heap32[g0] = r3;
        functionTable[r0 >> numDefine2](i7);
        if (uint(r2) > uint(numDefine9)) {
          r3 = r2;
        } else {
          r3 = zl13sFileStdout;
        }
        r0 = r3 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine4];
        heapClassInst.heap32[g0] = r3;
        functionTable[r0 >> numDefine2](i7);
        if (!(uint(r2) < uint(numDefine10))) {
          heapClassInst.heap32[g0] = r3;
          zdlPv(i7);
        }
      }
    }
  }
  r0 = sp + numDefineNeg352;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine20] = 0;
  heapClassInst.heap32[r0 + numDefine22] = r1;
  heapClassInst.heap32[r0 + numDefine21] = 0;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znkst8messagesIcE8doCloseEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  zn4Rw14RwCatCloseEi(i7);
  return;
}

function znkst8messagesIcE6doGetEiiiRKSs(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[fp + -1] = r0;
  if (!(r0 < 0)) {
    r0 = sp + numDefineNeg4;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = 0;
    zn4RwL20RwManageCatDataERiPNS18RwOpenCatDataE(i7);
    r0 = commonVariable.rg0;
    if (!(r0 === 0)) {
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0];
      if (!(r0 === -1)) {
        r1 = zn4RwL12RwCatlistE2E1;
        r2 = zn4RwL12RwCatlistE2E0;
        r1 = r1 >> numDefine2;
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r1 = heapClassInst.heap32[r1];
        r1 = (r1 - r2) | 0;
        r1 = r1 >> numDefine2;
        r3 = 0;
        repeat5: while (true) {
          if (uint(r1) <= uint(r3)) {
            break repeat5;
          } else {
            r4 = r3 << numDefine2;
            r4 = (r2 + r4) | 0;
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            if (r4 === 0) {
              break repeat5;
            } else {
              if (r4 !== r0) {
                r3 = (r3 + 1) | 0;
                continue repeat5;
              } else {
                break repeat5;
              }
            }
          }
        }
      }
    }
  }
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + numDefine5];
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r3 = r2 >> numDefine2;
  r4 = heapClassInst.heap32[r3 + numDefineNeg3];
  if (r4 === -1) {
    r2 = heapClassInst.heap32[r3 + -1];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r2;
    znss10CGetRepEjj(i7);
    r0 = r0 >> numDefine2;
    r3 = (commonVariable.rg0 + numDefine12) | 0;
    heapClassInst.heap32[r0] = r3;
    r0 = heapClassInst.heap32[r1];
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    memcpy(i7);
  } else {
    r1 = (r2 + numDefineNeg12) | 0;
    r0 = r0 >> numDefine2;
    r3 = znss11CNullRefE;
    heapClassInst.heap32[r0] = r2;
    if (!(r1 === r3)) {
      r0 = r1 >> numDefine2;
      r1 = (r4 + 1) | 0;
      heapClassInst.heap32[r0] = r1;
      return;
    }
  }
  return;
}

function znkst8messagesIcE7doOpenERKSsRKSt6locale(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  heapClassInst.heap32[g0] = 1;
  znwj(i7);
  r0 = commonVariable.rg0;
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r0;
    zdlPv(i7);
  }
  r0 = -1;
  commonVariable.rg0 = r0;
  return;
}

function znst8messagesIcED0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn4Rw10RwFacetE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[r2 + numDefine5] = -1;
  r1 = heapClassInst.heap32[r2 + 1];
  r3 = heapClassInst.heap32[r2 + numDefine2];
  if (!(r1 === r3)) {
    if (!(r1 === 0)) {
      heapClassInst.heap32[g0] = r1;
      zdaPv(i7);
    }
  }
  r1 = zzn4Rw10RwFacetD4EvE9destroyed;
  heapClassInst.heap32[r2 + 1] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r1 !== -1)) {
    r1 = heapClassInst.heap32[r2 + numDefine3];
    heapClassInst.heap32[g0] = r1;
    zdlPv(i7);
  }
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znst8messagesIcED1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn4Rw10RwFacetE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  heapClassInst.heap32[r0 + numDefine5] = -1;
  r1 = heapClassInst.heap32[r0 + 1];
  r2 = heapClassInst.heap32[r0 + numDefine2];
  if (!(r1 === r2)) {
    if (!(r1 === 0)) {
      heapClassInst.heap32[g0] = r1;
      zdaPv(i7);
    }
  }
  r1 = zzn4Rw10RwFacetD4EvE9destroyed;
  heapClassInst.heap32[r0 + 1] = r1;
  r1 = heapClassInst.heap32[r0 + numDefine4];
  if (!(r1 !== -1)) {
    r0 = heapClassInst.heap32[r0 + numDefine3];
    heapClassInst.heap32[g0] = r0;
    zdlPv(i7);
  }
  return;
}

function zn4Rw14RwPodArrayIcLj256EE6appendEPKcj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[r1];
  r4 = (r3 + r2) | 0;
  r5 = heapClassInst.heap32[fp + 1];
  if (uint(r4) > uint(numDefine255)) {
    r3 = (r4 + 1) | 0;
    heapClassInst.heap32[g0] = r3;
    znaj(i7);
    r7 = commonVariable.rg0;
    r3 = heapClassInst.heap32[r1];
    r6 = heapClassInst.heap32[r1 + 1];
    heapClassInst.heap32[g0] = r7;
    heapClassInst.heap32[g0 + 1] = r6;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    memcpy(i7);
    r3 = heapClassInst.heap32[r1 + 1];
    r6 = (r0 + numDefine8) | 0;
    if (!(r3 === r6)) {
      if (!(r3 === 0)) {
        heapClassInst.heap32[g0] = r3;
        zdaPv(i7);
      }
    }
    r6 = (r0 + numDefine4) | 0;
    heapClassInst.heap32[r1 + 1] = r7;
    r3 = heapClassInst.heap32[r1];
  } else {
    r6 = (r0 + numDefine4) | 0;
    r7 = heapClassInst.heap32[r1 + 1];
  }
  r3 = (r7 + r3) | 0;
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  memcpy(i7);
  r2 = r6 >> numDefine2;
  heapClassInst.heap32[r1] = r4;
  r1 = heapClassInst.heap32[r2];
  r2 = 0;
  heapClassInst.heap8[r1 + r4] = r2;
  commonVariable.rg0 = r0;
  return;
}

function znss10CGetRepEjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  repeat1: do {
    if (uint(r0) < uint(numDefineNeg13)) {
      if (uint(r0) < uint(r1)) {
        r2 = twoEStr4362;
        r3 = twoEStr3361;
        heapClassInst.heap32[g0] = numDefine8;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        heapClassInst.heap32[g0 + numDefine4] = r0;
        zn4Rw10RwThrowEiz(i7);
        label = numDefine6;
        break repeat1;
      } else {
        label = numDefine6;
        break repeat1;
      }
    } else {
      if (uint(r1) > uint(numDefineNeg14)) {
        r0 = twoEStr2360;
        r2 = twoEStr3361;
        heapClassInst.heap32[g0] = numDefine8;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        heapClassInst.heap32[g0 + numDefine4] = numDefineNeg14;
        zn4Rw10RwThrowEiz(i7);
        r0 = r1;
        label = numDefine8;
      } else {
        r0 = r1;
        label = numDefine6;
      }
    }
  } while (false);
  if (label === numDefine6) {
    if (r0 === 0) {
      r0 = znss11CNullRefE;
      commonVariable.rg0 = r0;
      return;
    }
  }
  r2 = (r0 + numDefine14) | 0;
  heapClassInst.heap32[g0] = r2;
  znwj(i7);
  r2 = commonVariable.rg0;
  if (!(r2 !== 0)) {
    heapClassInst.heap32[g0] = numDefine3;
    zn4Rw10RwThrowEiz(i7);
  }
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r3] = 0;
  heapClassInst.heap32[r3 + 1] = r0;
  r0 = (r1 + r2) | 0;
  r4 = 0;
  heapClassInst.heap32[r3 + numDefine2] = r1;
  heapClassInst.heap8[r0 + numDefine12] = r4;
  commonVariable.rg0 = r2;
  return;
}

function znkst9typeInfo15IsFunctionPEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znst9typeInfoD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znst9typeInfoD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function tlsfFree(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  if (!(r0 === 0)) {
    r1 = heapClassInst.heap32[fp];
    r2 = r0 >> numDefine2;
    r3 = heapClassInst.heap32[r2 + -1];
    r4 = sCurrentMemory;
    r5 = (r3 + numDefineNeg4) | 0;
    r4 = r4 >> numDefine2;
    r5 = r5 & numDefineNeg4;
    r6 = heapClassInst.heap32[r4];
    r3 = r3 & numDefineNeg4;
    r5 = (r0 + r5) | 0;
    r3 = (r6 - r3) | 0;
    r0 = (r0 + numDefineNeg8) | 0;
    r5 = r5 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    heapClassInst.heap32[r5] = r0;
    r3 = heapClassInst.heap32[r5 + 1];
    r3 = r3 | numDefine2;
    heapClassInst.heap32[r5 + 1] = r3;
    r3 = heapClassInst.heap32[r2 + -1];
    r4 = r3 | 1;
    heapClassInst.heap32[r2 + -1] = r4;
    r3 = r3 & numDefine2;
    if (r3 !== 0) {
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0];
      r3 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + 1];
      r5 = r4 & numDefineNeg4;
      if (uint(r5) > uint(numDefine255)) {
        r4 = r5 >>> 1;
        r4 = r5 | r4;
        r6 = r4 >>> numDefine2;
        r4 = r4 | r6;
        r6 = r4 >>> numDefine4;
        r4 = r4 | r6;
        r6 = r4 >>> numDefine8;
        r4 = r4 | r6;
        r6 = r4 >>> numDefine16;
        r4 = r4 | r6;
        r6 = r4 ^ -1;
        r7 = numDefine55765;
        r6 = r6 >>> 1;
        r4 = r7 & ~r4;
        r6 = r6 & numDefine55765;
        r4 = (r4 + r6) | 0;
        r6 = r4 >>> numDefine2;
        r4 = r4 & numDefine93459;
        r6 = r6 & numDefine93459;
        r4 = (r4 + r6) | 0;
        r6 = r4 >>> numDefine4;
        r4 = r4 & numDefine45135;
        r6 = r6 & numDefine45135;
        r4 = (r4 + r6) | 0;
        r6 = r4 >>> numDefine8;
        r4 = r4 & numDefine11935;
        r6 = r6 & numDefine11935;
        r4 = (r4 + r6) | 0;
        r6 = r4 & numDefine65535;
        r4 = r4 >>> numDefine16;
        r7 = numDefine26;
        r4 = (r6 + r4) | 0;
        r6 = (r7 - r4) | 0;
        r5 = r5 >>> r6;
        r6 = numDefine24;
        r5 = r5 ^ numDefine32;
        r4 = (r6 - r4) | 0;
      } else {
        r5 = r4 >>> numDefine3;
        r4 = 0;
      }
      r6 = r4 << numDefine7;
      r7 = heapClassInst.heap32[r3 + numDefine2];
      r8 = heapClassInst.heap32[r3 + numDefine3];
      r6 = (r1 + r6) | 0;
      r9 = r5 << numDefine2;
      r6 = (r6 + r9) | 0;
      r9 = r7 >> numDefine2;
      r10 = r8 >> numDefine2;
      heapClassInst.heap32[r9 + numDefine3] = r8;
      r8 = r6 >> numDefine2;
      heapClassInst.heap32[r10 + numDefine2] = r7;
      r8 = heapClassInst.heap32[r8 + numDefine24];
      if (!(r8 !== r0)) {
        r6 = (r6 + numDefine96) | 0;
        r6 = r6 >> numDefine2;
        r8 = blockNull;
        heapClassInst.heap32[r6] = r7;
        if (!(r7 !== r8)) {
          r6 = r4 << numDefine2;
          r6 = (r1 + r6) | 0;
          r6 = r6 >> numDefine2;
          r7 = 1;
          r5 = r7 << r5;
          r8 = heapClassInst.heap32[r6 + 1];
          r5 = r8 & ~r5;
          heapClassInst.heap32[r6 + 1] = r5;
          if (!(r5 !== 0)) {
            r5 = r1 >> numDefine2;
            r4 = r7 << r4;
            r6 = heapClassInst.heap32[r5];
            r4 = r6 & ~r4;
            heapClassInst.heap32[r5] = r4;
          }
        }
      }
      r4 = (r0 + numDefine8) | 0;
      r2 = heapClassInst.heap32[r2 + -1];
      r5 = heapClassInst.heap32[r3 + 1];
      r2 = r2 & numDefineNeg4;
      r2 = (r2 + r5) | 0;
      r5 = r2 & numDefineNeg4;
      r4 = (r4 + r5) | 0;
      r2 = (r2 + numDefine4) | 0;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r3 + 1] = r2;
      heapClassInst.heap32[r4] = r0;
    }
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r0;
    blockMergeNext(i7);
    r0 = commonVariable.rg0;
    r2 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + 1];
    r3 = r2 & numDefineNeg4;
    if (uint(r3) > uint(numDefine255)) {
      r2 = r3 >>> 1;
      r2 = r3 | r2;
      r4 = r2 >>> numDefine2;
      r2 = r2 | r4;
      r4 = r2 >>> numDefine4;
      r2 = r2 | r4;
      r4 = r2 >>> numDefine8;
      r2 = r2 | r4;
      r4 = r2 >>> numDefine16;
      r2 = r2 | r4;
      r4 = r2 ^ -1;
      r5 = numDefine55765;
      r4 = r4 >>> 1;
      r2 = r5 & ~r2;
      r4 = r4 & numDefine55765;
      r2 = (r2 + r4) | 0;
      r4 = r2 >>> numDefine2;
      r2 = r2 & numDefine93459;
      r4 = r4 & numDefine93459;
      r2 = (r2 + r4) | 0;
      r4 = r2 >>> numDefine4;
      r2 = r2 & numDefine45135;
      r4 = r4 & numDefine45135;
      r2 = (r2 + r4) | 0;
      r4 = r2 >>> numDefine8;
      r2 = r2 & numDefine11935;
      r4 = r4 & numDefine11935;
      r2 = (r2 + r4) | 0;
      r4 = r2 & numDefine65535;
      r2 = r2 >>> numDefine16;
      r5 = numDefine26;
      r2 = (r4 + r2) | 0;
      r4 = (r5 - r2) | 0;
      r3 = r3 >>> r4;
      r4 = numDefine24;
      r3 = r3 ^ numDefine32;
      r2 = (r4 - r2) | 0;
    } else {
      r3 = r2 >>> numDefine3;
      r2 = 0;
    }
    r4 = r2 << numDefine7;
    r4 = (r1 + r4) | 0;
    r5 = r3 << numDefine2;
    r4 = (r4 + r5) | 0;
    r4 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[r4 + numDefine24];
    r6 = r0 >> numDefine2;
    r7 = blockNull;
    heapClassInst.heap32[r6 + numDefine2] = r5;
    r5 = r5 >> numDefine2;
    heapClassInst.heap32[r6 + numDefine3] = r7;
    heapClassInst.heap32[r5 + numDefine3] = r0;
    r5 = 1;
    r6 = r1 >> numDefine2;
    heapClassInst.heap32[r4 + numDefine24] = r0;
    r0 = r2 << numDefine2;
    r2 = r5 << r2;
    r4 = heapClassInst.heap32[r6];
    r0 = (r1 + r0) | 0;
    r1 = r4 | r2;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r6] = r1;
    r1 = r5 << r3;
    r2 = heapClassInst.heap32[r0 + 1];
    r1 = r2 | r1;
    heapClassInst.heap32[r0 + 1] = r1;
  }
  return;
}

function stricmp(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r5 = numDefine26;
  repeat1: while (true) {
    r2 = heapClassInst.heap8[r1];
    r3 = heapClassInst.heap8[r0];
    r4 = (r2 + numDefineNeg65) | 0;
    r2 = (r2 + numDefineNeg33) | 0;
    r6 = (r3 + numDefineNeg65) | 0;
    r3 = (r3 + numDefineNeg33) | 0;
    r2 = uint(r4) < uint(r5) ? r2 : r4;
    r3 = uint(r6) < uint(r5) ? r3 : r6;
    if (r2 !== r3) {
      break repeat1;
    } else {
      r0 = (r0 + 1) | 0;
      r1 = (r1 + 1) | 0;
      if (r3 !== numDefineNeg65) {
        continue repeat1;
      } else {
        break repeat1;
      }
    }
  }
  r0 = (r3 - r2) | 0;
  commonVariable.rg0 = r0;
  return;
}

function strcasecmp(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r5 = numDefine26;
  repeat1: while (true) {
    r2 = heapClassInst.heap8[r1];
    r3 = heapClassInst.heap8[r0];
    r4 = (r2 + numDefineNeg65) | 0;
    r2 = (r2 + numDefineNeg33) | 0;
    r6 = (r3 + numDefineNeg65) | 0;
    r3 = (r3 + numDefineNeg33) | 0;
    r2 = uint(r4) < uint(r5) ? r2 : r4;
    r3 = uint(r6) < uint(r5) ? r3 : r6;
    if (r2 !== r3) {
      break repeat1;
    } else {
      r1 = (r1 + 1) | 0;
      r0 = (r0 + 1) | 0;
      if (r3 !== numDefineNeg65) {
        continue repeat1;
      } else {
        break repeat1;
      }
    }
  }
  r0 = (r3 - r2) | 0;
  commonVariable.rg0 = r0;
  return;
}

function memmove(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  repeat1: do {
    if (!(r0 === r1)) {
      r2 = heapClassInst.heap32[fp + numDefine2];
      if (uint(r0) <= uint(r1)) {
        if (!(r2 === 0)) {
          r3 = 0;
          r2 = (r3 - r2) | 0;
          repeat6: while (true) {
            r3 = (r0 - r2) | 0;
            r4 = (r2 + 1) | 0;
            r2 = (r1 - r2) | 0;
            r3 = heapClassInst.heapU8[r3 + -1];
            heapClassInst.heap8[r2 + -1] = r3;
            r2 = r4;
            if (r4 !== 0) {
              continue repeat6;
            } else {
              break repeat1;
            }
          }
        }
      } else {
        if (!(r2 === 0)) {
          r3 = r1;
          repeat10: while (true) {
            r4 = heapClassInst.heapU8[r0];
            r2 = (r2 + -1) | 0;
            r5 = (r3 + 1) | 0;
            r0 = (r0 + 1) | 0;
            heapClassInst.heap8[r3] = r4;
            r3 = r5;
            if (r2 === 0) {
              break repeat1;
            } else {
              continue repeat10;
            }
          }
        }
      }
    }
  } while (false);
  commonVariable.rg0 = r1;
  return;
}

function strncasecmp(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = 0;
  r7 = numDefine26;
  repeat1: while (true) {
    if (r3 >= r2) {
      label = numDefine5;
      break repeat1;
    } else {
      r4 = heapClassInst.heap8[r1 + r3];
      r5 = heapClassInst.heap8[r0 + r3];
      r6 = (r4 + numDefineNeg65) | 0;
      r4 = (r4 + numDefineNeg33) | 0;
      r8 = (r5 + numDefineNeg65) | 0;
      r5 = (r5 + numDefineNeg33) | 0;
      r4 = uint(r6) < uint(r7) ? r4 : r6;
      r5 = uint(r8) < uint(r7) ? r5 : r8;
      if (r4 !== r5) {
        label = numDefine4;
        break repeat1;
      } else {
        r3 = (r3 + 1) | 0;
        if (r5 !== numDefineNeg65) {
          continue repeat1;
        } else {
          label = numDefine4;
          break repeat1;
        }
      }
    }
  }
  switch (label) {
    case numDefine5:
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    case numDefine4:
      r0 = (r5 - r4) | 0;
      commonVariable.rg0 = r0;
      return;
    default:
      break;
  }
}

function strncmp(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  if (uint(r0) > uint(numDefine3)) {
    r5 = r0 >>> numDefine2;
    r1 = (r1 + numDefine2) | 0;
    repeat3: while (true) {
      r3 = heapClassInst.heapU8[r1 + numDefineNeg2];
      r4 = heapClassInst.heapU8[r2];
      if (r3 === 0) {
        label = numDefine5;
        break repeat3;
      } else {
        r6 = r4 & numDefine255;
        if (r3 === r6) {
          r3 = heapClassInst.heapU8[r1 + -1];
          r4 = heapClassInst.heapU8[r2 + 1];
          if (r3 === 0) {
            label = numDefine5;
            break repeat3;
          } else {
            r6 = r4 & numDefine255;
            if (r3 === r6) {
              r3 = heapClassInst.heapU8[r1];
              r4 = heapClassInst.heapU8[r2 + numDefine2];
              if (r3 === 0) {
                label = numDefine5;
                break repeat3;
              } else {
                r6 = r4 & numDefine255;
                if (r3 === r6) {
                  r3 = heapClassInst.heapU8[r1 + 1];
                  r4 = heapClassInst.heapU8[r2 + numDefine3];
                  if (r3 === 0) {
                    label = numDefine5;
                    break repeat3;
                  } else {
                    r6 = r4 & numDefine255;
                    if (r3 === r6) {
                      r5 = (r5 + -1) | 0;
                      r1 = (r1 + numDefine4) | 0;
                      r2 = (r2 + numDefine4) | 0;
                      if (r5 !== 0) {
                        label = numDefine3;
                      } else {
                        label = numDefine13;
                        break repeat3;
                      }
                    } else {
                      label = numDefine5;
                      break repeat3;
                    }
                  }
                } else {
                  label = numDefine5;
                  break repeat3;
                }
              }
            } else {
              label = numDefine5;
              break repeat3;
            }
          }
        } else {
          label = numDefine5;
          break repeat3;
        }
      }
    }
    switch (label) {
      case numDefine5:
        r1 = r4 & numDefine255;
        r1 = (r3 - r1) | 0;
        commonVariable.rg0 = r1;
        return;
      case numDefine13:
        r0 = r0 & numDefine3;
        r1 = (r1 + numDefineNeg2) | 0;
        break;
      default:
        break;
    }
  } else {
    r3 = 0;
    r4 = r3;
  }
  repeat17: while (true) {
    if (r0 !== 0) {
      r3 = heapClassInst.heapU8[r1];
      r4 = heapClassInst.heapU8[r2];
      if (r3 === 0) {
        label = numDefine16;
        break repeat17;
      } else {
        r5 = r4 & numDefine255;
        if (r3 === r5) {
          r0 = (r0 + -1) | 0;
          r1 = (r1 + 1) | 0;
          r2 = (r2 + 1) | 0;
          continue repeat17;
        } else {
          label = numDefine16;
          break repeat17;
        }
      }
    } else {
      label = numDefine19;
      break repeat17;
    }
  }
  switch (label) {
    case numDefine16:
      r0 = r4 & numDefine255;
      r0 = (r3 - r0) | 0;
      commonVariable.rg0 = r0;
      return;
    case numDefine19:
      r0 = r3 & numDefine255;
      r1 = r4 & numDefine255;
      r0 = (r0 - r1) | 0;
      commonVariable.rg0 = r0;
      return;
    default:
      break;
  }
}

function quicksort(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let r24: number = 0;
  let r25: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[fp + numDefineNeg4] = r0;
  r1 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[fp + numDefineNeg3] = r1;
  if (!(r0 <= r1)) {
    r0 = heapClassInst.heap32[fp];
    r1 = heapClassInst.heap32[fp + numDefine3];
    r2 = numDefine4;
    r3 = heapClassInst.heap32[fp + numDefineNeg4];
    r4 = r3 << numDefine2;
    r5 = (r0 + r4) | 0;
    r6 = numDefineNeg4;
    r7 = numDefineNeg8;
    r2 = (r2 - r0) | 0;
    r3 = (r3 + -1) | 0;
    r8 = (r0 + numDefine4) | 0;
    r6 = (r6 - r0) | 0;
    heapClassInst.heap32[fp + -1] = r6;
    r6 = (r5 + numDefineNeg4) | 0;
    heapClassInst.heap32[fp + numDefineNeg2] = r6;
    r6 = (r7 - r0) | 0;
    r2 = (r2 - r4) | 0;
    heapClassInst.heap32[fp + numDefineNeg6] = r2;
    repeat3: while (true) {
      r2 = heapClassInst.heap32[fp + numDefineNeg3];
      r4 = (r2 + -1) | 0;
      r7 = (r2 + 1) | 0;
      r9 = -1;
      r10 = numDefineNeg2;
      heapClassInst.heap32[fp + numDefineNeg5] = r2;
      r2 = heapClassInst.heap32[fp + numDefineNeg4];
      r11 = r4;
      repeat5: while (true) {
        r12 = r4 << numDefine2;
        r13 = (r0 + r12) | 0;
        r14 = (r12 + numDefine4) | 0;
        r15 = heapClassInst.heap32[fp + -1];
        r15 = (r15 - r12) | 0;
        r16 = (r8 + r12) | 0;
        r12 = (r6 - r12) | 0;
        repeat7: while (true) {
          r17 = r12;
          r18 = r16;
          r19 = r15;
          r20 = r14;
          r21 = r4;
          r22 = r13;
          if (r3 === r21) {
            break repeat7;
          } else {
            r4 = (r0 + r20) | 0;
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r5;
            r13 = (r22 + numDefine4) | 0;
            r4 = (r21 + 1) | 0;
            r14 = (r20 + numDefine4) | 0;
            r15 = (r19 + numDefineNeg4) | 0;
            r16 = (r18 + numDefine4) | 0;
            r12 = (r17 + numDefineNeg4) | 0;
            functionTable[r1 >> numDefine2](i7);
            r23 = commonVariable.rg0;
            if (!(r23 < 0)) {
              break repeat7;
            }
          }
        }
        r4 = r2 << numDefine2;
        r12 = (r0 + r4) | 0;
        r13 = 0;
        r14 = (r13 - r12) | 0;
        r4 = (r21 + 1) | 0;
        r15 = (r12 + numDefineNeg4) | 0;
        r16 = r14;
        repeat11: while (true) {
          r23 = r14;
          r24 = r16;
          r25 = r2;
          r2 = (r15 + r13) | 0;
          heapClassInst.heap32[g0] = r5;
          heapClassInst.heap32[g0 + 1] = r2;
          r13 = (r13 + numDefineNeg4) | 0;
          r2 = (r25 + -1) | 0;
          functionTable[r1 >> numDefine2](i7);
          r14 = commonVariable.rg0;
          if (r14 > -1) {
            break repeat11;
          } else {
            r16 = (r24 + numDefine4) | 0;
            r14 = (r23 + numDefine4) | 0;
            if (!(r7 !== r25)) {
              break repeat11;
            }
          }
        }
        if (r4 >= r2) {
          break repeat5;
        } else {
          r17 = 0;
          repeat16: while (true) {
            r22 = (r17 - r19) | 0;
            r14 = (r17 - r24) | 0;
            r15 = heapClassInst.heapU8[r22];
            r14 = heapClassInst.heapU8[r14 + numDefineNeg4];
            r16 = (r17 + 1) | 0;
            r17 = (r17 - r23) | 0;
            heapClassInst.heap8[r22] = r14;
            heapClassInst.heap8[r17 + numDefineNeg4] = r15;
            r17 = r16;
            if (!(r16 !== numDefine4)) {
              break repeat16;
            }
          }
          r17 = (r0 + r20) | 0;
          heapClassInst.heap32[g0] = r17;
          heapClassInst.heap32[g0 + 1] = r5;
          functionTable[r1 >> numDefine2](i7);
          r17 = commonVariable.rg0;
          repeat19: do {
            if (r17 === 0) {
              r17 = r11 << numDefine2;
              r11 = (r11 + 1) | 0;
              r17 = (r8 + r17) | 0;
              r22 = 0;
              while (true) {
                r14 = (r18 - r22) | 0;
                r15 = (r17 - r22) | 0;
                r16 = heapClassInst.heapU8[r15];
                r19 = heapClassInst.heapU8[r14];
                r22 = (r22 + -1) | 0;
                heapClassInst.heap8[r15] = r19;
                heapClassInst.heap8[r14] = r16;
                if (!(r22 !== numDefineNeg4)) {
                  break repeat19;
                }
              }
            }
          } while (false);
          r17 = (r12 + r13) | 0;
          heapClassInst.heap32[g0] = r5;
          heapClassInst.heap32[g0 + 1] = r17;
          functionTable[r1 >> numDefine2](i7);
          r17 = commonVariable.rg0;
          if (!(r17 !== 0)) {
            r4 = (r21 + 1) | 0;
            r17 = 0;
            repeat25: while (true) {
              r18 = heapClassInst.heap32[fp + numDefineNeg2];
              r18 = (r17 + r18) | 0;
              r21 = r10 << numDefine2;
              r18 = (r18 - r21) | 0;
              r21 = (r17 + r12) | 0;
              r21 = heapClassInst.heapU8[r21 + r13];
              r22 = heapClassInst.heapU8[r18 + numDefineNeg8];
              r14 = (r17 + r12) | 0;
              r17 = (r17 + 1) | 0;
              heapClassInst.heap8[r14 + r13] = r22;
              heapClassInst.heap8[r18 + numDefineNeg8] = r21;
              if (r17 === numDefine4) {
                break repeat25;
              }
            }
            r10 = (r10 + 1) | 0;
            r9 = (r9 + 1) | 0;
          }
        }
      }
      r2 = heapClassInst.heap32[fp + numDefineNeg4];
      r2 = (r2 - r10) | 0;
      r4 = 0;
      r2 = (r2 + numDefineNeg2) | 0;
      r7 = (r4 - r22) | 0;
      repeat29: while (true) {
        r12 = (r5 - r4) | 0;
        r13 = (r18 - r4) | 0;
        r14 = heapClassInst.heapU8[r13];
        r15 = heapClassInst.heapU8[r12];
        r4 = (r4 + -1) | 0;
        heapClassInst.heap8[r13] = r15;
        heapClassInst.heap8[r12] = r14;
        if (!(r4 !== numDefineNeg4)) {
          break repeat29;
        }
      }
      r4 = (r21 + numDefine2) | 0;
      r12 = heapClassInst.heap32[fp + numDefineNeg3];
      if (r12 < r11) {
        r13 = r12 << numDefine2;
        r14 = 0;
        r13 = (r0 + r13) | 0;
        r13 = (r14 - r13) | 0;
        r12 = (r11 - r12) | 0;
        repeat34: while (true) {
          r15 = r14;
          repeat36: while (true) {
            r16 = (r15 - r7) | 0;
            r18 = (r15 - r13) | 0;
            r19 = heapClassInst.heapU8[r18];
            r20 = heapClassInst.heapU8[r16];
            r15 = (r15 + 1) | 0;
            heapClassInst.heap8[r18] = r20;
            heapClassInst.heap8[r16] = r19;
            if (!(r15 !== numDefine4)) {
              break repeat36;
            }
          }
          r12 = (r12 + -1) | 0;
          r13 = (r13 + numDefineNeg4) | 0;
          r7 = (r7 + numDefine4) | 0;
          if (!(r12 !== 0)) {
            break repeat34;
          }
        }
        r7 = heapClassInst.heap32[fp + numDefineNeg3];
        r7 = (r7 - r11) | 0;
        r7 = (r7 + r21) | 0;
      } else {
        r7 = r21;
      }
      if (r3 > r2) {
        r2 = heapClassInst.heap32[fp + numDefineNeg6];
        repeat44: while (true) {
          r4 = 0;
          repeat46: while (true) {
            r11 = (r4 - r2) | 0;
            r12 = (r4 - r17) | 0;
            r13 = heapClassInst.heapU8[r12];
            r14 = heapClassInst.heapU8[r11];
            r4 = (r4 + 1) | 0;
            heapClassInst.heap8[r12] = r14;
            heapClassInst.heap8[r11] = r13;
            if (!(r4 !== numDefine4)) {
              break repeat46;
            }
          }
          r9 = (r9 + -1) | 0;
          r17 = (r17 + numDefineNeg4) | 0;
          r2 = (r2 + numDefine4) | 0;
          if (!(r9 !== 0)) {
            break repeat44;
          }
        }
        r2 = (r10 + r21) | 0;
        r2 = (r2 + numDefine3) | 0;
        heapClassInst.heap32[fp + numDefineNeg3] = r2;
      } else {
        heapClassInst.heap32[fp + numDefineNeg3] = r4;
      }
      heapClassInst.heap32[g0] = r0;
      r2 = heapClassInst.heap32[fp + numDefineNeg5];
      heapClassInst.heap32[g0 + 1] = r2;
      heapClassInst.heap32[g0 + numDefine2] = r7;
      heapClassInst.heap32[g0 + numDefine3] = r1;
      quicksort(i7);
      r4 = heapClassInst.heap32[fp + numDefineNeg3];
      r2 = heapClassInst.heap32[fp + numDefineNeg4];
      if (r4 < r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function sgetc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = heapClassInst.heapU8[r1];
  r1 = (r1 + 1) | 0;
  heapClassInst.heap32[r0] = r1;
  if (r2 === 0) {
    r0 = -1;
    commonVariable.rg0 = r0;
    return;
  } else {
    commonVariable.rg0 = r2;
    return;
  }
}

function sputc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = (r1 + -1) | 0;
  heapClassInst.heap32[r0] = r2;
  r0 = heapClassInst.heapU8[r1 + -1];
  r1 = heapClassInst.heap32[fp];
  r2 = -1;
  r0 = r0 === r1 ? r1 : r2;
  commonVariable.rg0 = r0;
  return;
}

function syncFetchAndAdd4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r0];
  r1 = (r2 + r1) | 0;
  heapClassInst.heap32[r0] = r1;
  commonVariable.rg0 = r2;
  return;
}

function muldi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  if (r0 < 0) {
    r5 = 0;
    r4 = 1;
    r0 = (r5 - r0) | 0;
    r6 = r1 !== 0 ? r4 : r5;
    r1 = (r5 - r1) | 0;
    r0 = (r0 - r6) | 0;
  } else {
    r4 = 0;
  }
  if (r3 < 0) {
    r5 = 0;
    r6 = 1;
    r3 = (r5 - r3) | 0;
    r6 = r2 !== 0 ? r6 : r5;
    r4 = r4 ^ 1;
    r2 = (r5 - r2) | 0;
    r3 = (r3 - r6) | 0;
  }
  r5 = r2 & numDefine65535;
  r6 = r1 & numDefine65535;
  r7 = r3 | r0;
  r8 = (r5 * r6) | 0;
  r9 = r2 | r1;
  r9 = r9 >>> numDefine16;
  if (r9 !== 0) {
    r9 = r1 >>> numDefine16;
    r10 = r2 >>> numDefine16;
    r11 = (r10 - r5) | 0;
    r12 = (r5 - r10) | 0;
    r13 = (r6 - r9) | 0;
    r14 = (r9 - r6) | 0;
    r15 = (r10 * r9) | 0;
    r11 = uint(r5) < uint(r10) ? r11 : r12;
    r12 = uint(r9) < uint(r6) ? r13 : r14;
    r11 = (r11 * r12) | 0;
    r12 = r15 >>> numDefine16;
    r12 = (r12 + r15) | 0;
    r13 = r15 << numDefine16;
    r14 = r11 << numDefine16;

    r6 = uint(r9) < uint(r6) ? 1 : 0;

    r5 = uint(r5) < uint(r10) ? 1 : 0;
    r5 = r6 ^ r5;
    r5 = r5 & 1;
    if (r5 === 0) {
      r5 = (r14 + r13) | 0;

      r6 = uint(r5) < uint(r13) ? 1 : 0;
      r11 = r11 >>> numDefine16;
      r11 = (r11 + r12) | 0;
      r6 = r6 & 1;
      r11 = (r11 + r6) | 0;
    } else {
      r5 = (r13 - r14) | 0;
      r11 = r11 >>> numDefine16;
      r14 = -1;
      r6 = 0;
      r11 = (r12 - r11) | 0;
      r12 = uint(r5) > uint(r13) ? r14 : r6;
      r11 = (r11 + r12) | 0;
    }
    r6 = r8 << numDefine16;
    r6 = (r5 + r6) | 0;
    r9 = (r6 + r8) | 0;

    r5 = uint(r6) < uint(r5) ? 1 : 0;
    r6 = r8 >>> numDefine16;

    r8 = uint(r9) < uint(r8) ? 1 : 0;
    r6 = (r11 + r6) | 0;
    r5 = r5 & 1;
    r5 = (r6 + r5) | 0;
    r8 = r8 & 1;
    r5 = (r5 + r8) | 0;
    r8 = r9;
  } else {
    r5 = 0;
  }
  if (r7 !== 0) {
    r6 = (r3 - r2) | 0;
    r7 = (r2 - r3) | 0;
    r9 = (r1 - r0) | 0;
    r10 = (r0 - r1) | 0;
    r6 = uint(r2) < uint(r3) ? r6 : r7;
    r7 = uint(r0) < uint(r1) ? r9 : r10;

    r1 = uint(r0) < uint(r1) ? 1 : 0;

    r2 = uint(r2) < uint(r3) ? 1 : 0;
    r9 = 0;
    r6 = (r6 * r7) | 0;
    r1 = r1 ^ r2;
    r2 = (r9 - r6) | 0;
    r1 = r1 !== 0 ? r2 : r6;
    r0 = (r3 * r0) | 0;
    r0 = (r1 + r0) | 0;
    r0 = (r0 + r8) | 0;
    r5 = (r0 + r5) | 0;
  }
  r0 = 0;
  r1 = 1;
  r2 = (r0 - r5) | 0;
  r1 = r8 !== 0 ? r1 : r0;
  r0 = (r0 - r8) | 0;
  r1 = (r2 - r1) | 0;
  r0 = r4 === 0 ? r8 : r0;
  r1 = r4 === 0 ? r5 : r1;
  commonVariable.rg0 = r0;
  commonVariable.rg1 = r1;
  return;
}

function fixdfdi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = sp + 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = r0 >>> numDefine20;
  r1 = r1 & numDefine2047;
  r2 = (r1 + numDefineNeg1023) | 0;
  if (r2 < 0) {
    r0 = 0;
    commonVariable.rg0 = r0;
    commonVariable.rg1 = r0;
    return;
  } else {
    r3 = heapClassInst.heap32[fp];
    r4 = r0 & numDefine48575;
    r0 = r0 >> numDefine31;
    r4 = r4 | numDefine48576;
    if (r2 < numDefine53) {
      r2 = numDefine1075;
      r1 = (r2 - r1) | 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r1;
      lshrdi3(i7);
      r1 = commonVariable.rg0;
      r3 = commonVariable.rg1;
    } else {
      r1 = (r1 + numDefineNeg1075) | 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r1;
      ashldi3(i7);
      r1 = commonVariable.rg0;
      r3 = commonVariable.rg1;
    }
    r2 = r3 ^ r0;
    r1 = r1 ^ r0;
    r3 = 1;
    r4 = 0;
    r2 = (r2 - r0) | 0;
    r3 = uint(r1) < uint(r0) ? r3 : r4;
    r0 = (r1 - r0) | 0;
    r1 = (r2 - r3) | 0;
    commonVariable.rg0 = r0;
    commonVariable.rg1 = r1;
    return;
  }
}

function floatdidf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  f0 = r0;
  f1 = numDefine67296;
  f2 = uint(r1);
  f0 = f0 * f1;
  f0 = f2 + f0;
  commonVariable.fg0 = f0;
  return;
}

function lshrdi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 & numDefine32;
  if (r2 === 0) {
    r2 = heapClassInst.heap32[fp];
    if (!(r0 === 0)) {
      r3 = numDefine32;
      r3 = (r3 - r0) | 0;
      r3 = r1 << r3;
      r2 = r2 >>> r0;
      r2 = r3 | r2;
      r1 = r1 >>> r0;
    }
    commonVariable.rg0 = r2;
    commonVariable.rg1 = r1;
    return;
  } else {
    r0 = (r0 + numDefineNeg32) | 0;
    r0 = r1 >>> r0;
    r1 = 0;
    commonVariable.rg0 = r0;
    commonVariable.rg1 = r1;
    return;
  }
}

function fixsfdi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >>> numDefine23;
  r1 = r1 & numDefine255;
  r2 = (r1 + numDefineNeg127) | 0;
  if (r2 < 0) {
    r0 = 0;
    commonVariable.rg0 = r0;
    commonVariable.rg1 = r0;
    return;
  } else {
    r3 = r0 & numDefine88607;
    r0 = r0 >> numDefine31;
    r3 = r3 | numDefine88608;
    r4 = 0;
    if (r2 < numDefine24) {
      r2 = numDefine150;
      r1 = (r2 - r1) | 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r1;
      lshrdi3(i7);
      r1 = commonVariable.rg0;
      r3 = commonVariable.rg1;
    } else {
      r1 = (r1 + numDefineNeg150) | 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r1;
      ashldi3(i7);
      r1 = commonVariable.rg0;
      r3 = commonVariable.rg1;
    }
    r2 = r3 ^ r0;
    r1 = r1 ^ r0;
    r3 = 1;
    r2 = (r2 - r0) | 0;
    r3 = uint(r1) < uint(r0) ? r3 : r4;
    r0 = (r1 - r0) | 0;
    r1 = (r2 - r3) | 0;
    commonVariable.rg0 = r0;
    commonVariable.rg1 = r1;
    return;
  }
}

function ashldi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 & numDefine32;
  if (r2 === 0) {
    r2 = heapClassInst.heap32[fp + 1];
    if (!(r0 === 0)) {
      r3 = numDefine32;
      r3 = (r3 - r0) | 0;
      r2 = r2 << r0;
      r3 = r1 >>> r3;
      r1 = r1 << r0;
      r2 = r2 | r3;
    }
    commonVariable.rg0 = r1;
    commonVariable.rg1 = r2;
    return;
  } else {
    r0 = (r0 + numDefineNeg32) | 0;
    r2 = 0;
    r0 = r1 << r0;
    commonVariable.rg0 = r2;
    commonVariable.rg1 = r0;
    return;
  }
}

function ashrdi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 & numDefine32;
  if (r2 === 0) {
    r2 = heapClassInst.heap32[fp];
    if (!(r0 === 0)) {
      r3 = numDefine32;
      r3 = (r3 - r0) | 0;
      r3 = r1 << r3;
      r2 = r2 >>> r0;
      r2 = r3 | r2;
      r1 = r1 >> r0;
    }
    commonVariable.rg0 = r2;
    commonVariable.rg1 = r1;
    return;
  } else {
    r0 = (r0 + numDefineNeg32) | 0;
    r0 = r1 >> r0;
    r1 = r1 >> numDefine31;
    commonVariable.rg0 = r0;
    commonVariable.rg1 = r1;
    return;
  }
}

function fixunsdfdi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = sp + 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = r0 >>> numDefine20;
  r1 = r1 & numDefine2047;
  r2 = (r1 + numDefineNeg1023) | 0;
  if (!(r2 < 0)) {
    if (!(r0 < 0)) {
      r3 = heapClassInst.heap32[fp];
      r0 = r0 & numDefine48575;
      r0 = r0 | numDefine48576;
      if (r2 < numDefine53) {
        r2 = numDefine1075;
        r1 = (r2 - r1) | 0;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        lshrdi3(i7);
        return;
      } else {
        r1 = (r1 + numDefineNeg1075) | 0;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        ashldi3(i7);
        return;
      }
    }
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  commonVariable.rg1 = r0;
  return;
}

function fixunssfdi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >>> numDefine23;
  r1 = r1 & numDefine255;
  r2 = (r1 + numDefineNeg127) | 0;
  if (!(r2 < 0)) {
    if (!(r0 < 0)) {
      r0 = r0 & numDefine88607;
      r0 = r0 | numDefine88608;
      r3 = 0;
      if (r2 < numDefine24) {
        r2 = numDefine150;
        r1 = (r2 - r1) | 0;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        lshrdi3(i7);
        return;
      } else {
        r1 = (r1 + numDefineNeg150) | 0;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        ashldi3(i7);
        return;
      }
    }
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  commonVariable.rg1 = r0;
  return;
}

function znk14CFileInterface12IsFileSystemEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout5freadEPvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = -1;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout5ftellEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout4feofEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout5fseekEli(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout6ungetcEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout6fflushEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileStdout6fcloseEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk11CFileSystem12IsFileSystemEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 1;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileSystem5freadEPvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  mandreelFread(i7);
  return;
}

function zn11CFileSystem6fwriteEPKvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = -1;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileSystem6fflushEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn11CFileSystem6fcloseEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  heapClassInst.heap32[g0] = r0;
  mandreelFclose(i7);
  return;
}

function zn11CFileSystem5ftellEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  heapClassInst.heap32[g0] = r0;
  mandreelFtell(i7);
  return;
}

function zn11CFileSystem4feofEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  heapClassInst.heap32[g0] = r0;
  mandreelFeof(i7);
  return;
}

function zn11CFileSystem5fseekEli(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  mandreelFseek(i7);
  return;
}

function zn11CFileSystem6ungetcEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  mandreelUngetc(i7);
  return;
}

function zn7CFileLS5freadEPvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  r3 = heapClassInst.heap32[r0 + numDefine4];
  r4 = heapClassInst.heap32[r0 + numDefine2];
  r2 = (r2 * r1) | 0;
  r5 = (r3 + r2) | 0;
  r6 = (r4 - r3) | 0;
  r2 = r5 > r4 ? r6 : r2;
  if (r2 < 0) {
    r0 = -1;
    commonVariable.rg0 = r0;
    return;
  } else {
    r4 = heapClassInst.heap32[fp + 1];
    r5 = heapClassInst.heap32[r0 + numDefine6];
    r3 = (r5 + r3) | 0;
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    memcpy(i7);
    r3 = heapClassInst.heap32[r0 + numDefine4];
    r3 = (r3 + r2) | 0;
    heapClassInst.heap32[r0 + numDefine4] = r3;
    r0 = Math.floor(uint(r2) / uint(r1));
    commonVariable.rg0 = r0;
    return;
  }
}

function zn7CFileLS5ftellEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine4];
  commonVariable.rg0 = r0;
  return;
}

function zn7CFileLS4feofEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine4];
  r0 = heapClassInst.heap32[r0 + numDefine2];

  r0 = r1 >= r0 ? 1 : 0;
  r0 = r0 & 1;
  commonVariable.rg0 = r0;
  return;
}

function zn7CFileLS5fseekEli(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  repeat1: do {
    if (r0 === 0) {
      r1 = r1 >> numDefine2;
    } else {
      if (r0 === 1) {
        r0 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine4];
        r1 = (r1 + r2) | 0;
        heapClassInst.heap32[r0 + numDefine4] = r1;
      } else {
        if (!(r0 !== numDefine2)) {
          r1 = r1 >> numDefine2;
          r0 = heapClassInst.heap32[r1 + numDefine2];
          r2 = (r0 + r2) | 0;
          break repeat1;
        }
      }
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    }
  } while (false);
  heapClassInst.heap32[r1 + numDefine4] = r2;
  r1 = 0;
  commonVariable.rg0 = r1;
  return;
}

function zn7CFileLS6ungetcEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = -1;
  commonVariable.rg0 = r0;
  return;
}

function zn10CFileCloud5freadEPvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  r3 = heapClassInst.heap32[r0 + numDefine4];
  r4 = heapClassInst.heap32[r0 + numDefine2];
  r2 = (r2 * r1) | 0;
  r5 = (r3 + r2) | 0;
  r6 = (r4 - r3) | 0;
  r2 = r5 > r4 ? r6 : r2;
  if (r2 < 0) {
    r0 = -1;
    commonVariable.rg0 = r0;
    return;
  } else {
    r4 = heapClassInst.heap32[fp + 1];
    r5 = heapClassInst.heap32[r0 + numDefine6];
    r3 = (r5 + r3) | 0;
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    memcpy(i7);
    r3 = heapClassInst.heap32[r0 + numDefine4];
    r3 = (r3 + r2) | 0;
    heapClassInst.heap32[r0 + numDefine4] = r3;
    r0 = Math.floor(uint(r2) / uint(r1));
    commonVariable.rg0 = r0;
    return;
  }
}

function zn10CFileCloud5ftellEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine4];
  commonVariable.rg0 = r0;
  return;
}

function zn10CFileCloud4feofEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine4];
  r0 = heapClassInst.heap32[r0 + numDefine2];

  r0 = r1 >= r0 ? 1 : 0;
  r0 = r0 & 1;
  commonVariable.rg0 = r0;
  return;
}

function zn10CFileCloud5fseekEli(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  repeat1: do {
    if (r0 === 0) {
      r1 = r1 >> numDefine2;
    } else {
      if (r0 === 1) {
        r0 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine4];
        r1 = (r1 + r2) | 0;
        heapClassInst.heap32[r0 + numDefine4] = r1;
      } else {
        if (!(r0 !== numDefine2)) {
          r1 = r1 >> numDefine2;
          r0 = heapClassInst.heap32[r1 + numDefine2];
          r2 = (r0 + r2) | 0;
          break repeat1;
        }
      }
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    }
  } while (false);
  heapClassInst.heap32[r1 + numDefine4] = r2;
  r1 = 0;
  commonVariable.rg0 = r1;
  return;
}

function zn10CFileCloud6ungetcEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = -1;
  commonVariable.rg0 = r0;
  return;
}

function zn7CFileLS6fwriteEPKvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine3];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + 1];
  r2 = (r1 * r2) | 0;
  r4 = heapClassInst.heap32[r0 + numDefine4];
  r5 = (r4 + r2) | 0;
  r6 = heapClassInst.heap32[r0 + numDefine3];
  if (r5 > r6) {
    r4 = (r2 + r4) | 0;
    r4 = (r4 + numDefine31072) | 0;
    heapClassInst.heap32[r0 + numDefine3] = r4;
    r5 = heapClassInst.heap32[r0 + numDefine6];
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r4;
    realloc(i7);
    r5 = commonVariable.rg0;
    heapClassInst.heap32[r0 + numDefine6] = r5;
    r4 = heapClassInst.heap32[r0 + numDefine4];
  } else {
    r5 = heapClassInst.heap32[r0 + numDefine6];
  }
  r4 = (r5 + r4) | 0;
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  memcpy(i7);
  r3 = heapClassInst.heap32[r0 + numDefine4];
  r2 = (r3 + r2) | 0;
  heapClassInst.heap32[r0 + numDefine4] = r2;
  r3 = heapClassInst.heap32[r0 + numDefine5];
  if (!(r2 <= r3)) {
    heapClassInst.heap32[r0 + numDefine5] = r2;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn7CFileLS6fflushEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine5];
  if (!(r1 === 0)) {
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine5];
    r1 = heapClassInst.heap32[r1 + numDefine6];
    r0 = (r0 + numDefine28) | 0;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    mandreelWritels(i7);
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn7CFileLS6fcloseEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine5];
  if (!(r1 === 0)) {
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine5];
    r1 = heapClassInst.heap32[r1 + numDefine6];
    r3 = (r0 + numDefine28) | 0;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    mandreelWritels(i7);
  }
  r1 = 0;
  r2 = r0 >> numDefine2;
  heapClassInst.heap8[r0 + numDefine4] = r1;
  r0 = heapClassInst.heap32[r2 + numDefine6];
  heapClassInst.heap32[g0] = r0;
  free(i7);
  commonVariable.rg0 = r1;
  return;
}

function zn10CFileCloud6fwriteEPKvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine3];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + 1];
  r2 = (r1 * r2) | 0;
  r4 = heapClassInst.heap32[r0 + numDefine4];
  r5 = (r4 + r2) | 0;
  r6 = heapClassInst.heap32[r0 + numDefine3];
  if (r5 > r6) {
    r4 = (r2 + r4) | 0;
    r4 = (r4 + numDefine31072) | 0;
    heapClassInst.heap32[r0 + numDefine3] = r4;
    r5 = heapClassInst.heap32[r0 + numDefine6];
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r4;
    realloc(i7);
    r5 = commonVariable.rg0;
    heapClassInst.heap32[r0 + numDefine6] = r5;
    r4 = heapClassInst.heap32[r0 + numDefine4];
  } else {
    r5 = heapClassInst.heap32[r0 + numDefine6];
  }
  r4 = (r5 + r4) | 0;
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  memcpy(i7);
  r3 = heapClassInst.heap32[r0 + numDefine4];
  r2 = (r3 + r2) | 0;
  heapClassInst.heap32[r0 + numDefine4] = r2;
  r3 = heapClassInst.heap32[r0 + numDefine5];
  if (!(r2 <= r3)) {
    heapClassInst.heap32[r0 + numDefine5] = r2;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn10CFileCloud6fflushEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine5];
  if (!(r1 === 0)) {
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine5];
    r3 = r2 << 1;
    heapClassInst.heap32[g0] = r3;
    mallocNew(i7);
    r4 = commonVariable.rg0;
    r1 = heapClassInst.heap32[r1 + numDefine6];
    r5 = sp + numDefineNeg4;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    heapClassInst.heap32[g0 + numDefine4] = r5;
    zn12mandreelB64L11b64EncodeEPKhjPcjjPNS6B64RCE(i7);
    r0 = (r0 + numDefine28) | 0;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r4;
    heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
    mandreelWritecloud(i7);
    heapClassInst.heap32[g0] = r4;
    free(i7);
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn10CFileCloud6fcloseEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine5];
  if (!(r1 === 0)) {
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine5];
    r3 = r2 << 1;
    heapClassInst.heap32[g0] = r3;
    mallocNew(i7);
    r4 = commonVariable.rg0;
    r1 = heapClassInst.heap32[r1 + numDefine6];
    r5 = sp + numDefineNeg4;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    heapClassInst.heap32[g0 + numDefine4] = r5;
    zn12mandreelB64L11b64EncodeEPKhjPcjjPNS6B64RCE(i7);
    r2 = (r0 + numDefine28) | 0;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r4;
    heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
    mandreelWritecloud(i7);
    heapClassInst.heap32[g0] = r4;
    free(i7);
  }
  r1 = 0;
  r2 = r0 >> numDefine2;
  heapClassInst.heap8[r0 + numDefine4] = r1;
  r0 = heapClassInst.heap32[r2 + numDefine6];
  heapClassInst.heap32[g0] = r0;
  free(i7);
  commonVariable.rg0 = r1;
  return;
}

function syncValCompareAndSwap4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = heapClassInst.heap32[fp + 1];
  if (!(r1 !== r2)) {
    r2 = heapClassInst.heap32[fp + numDefine2];
    heapClassInst.heap32[r0] = r2;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn11CFileStdout6fwriteEPKvjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16392;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + numDefine3];
  r0 = (r1 * r0) | 0;
  if (r0 !== 0) {
    r2 = heapClassInst.heap32[fp + 1];
    r3 = sp + numDefineNeg16384;
    r4 = r0;
    repeat3: while (true) {
      r5 = heapClassInst.heapU8[r2];
      r4 = (r4 + -1) | 0;
      r2 = (r2 + 1) | 0;
      r6 = (r3 + 1) | 0;
      heapClassInst.heap8[r3] = r5;
      r3 = r6;
      if (!(r4 !== 0)) {
        break repeat3;
      }
    }
    r2 = sp + numDefineNeg16384;
    r0 = (r2 + r0) | 0;
  } else {
    r0 = sp + numDefineNeg16384;
  }
  r2 = 0;
  heapClassInst.heap8[r0] = r2;
  r0 = sp + numDefineNeg16384;
  heapClassInst.heap32[g0] = r0;
  puts(i7);
  commonVariable.rg0 = r1;
  return;
}

function fopen(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg2064;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0];
  r2 = numDefine46;
  r3 = numDefine92;
  r4 = heapClassInst.heapU8[r0 + 1];
  r5 = numDefine47;

  r1 = r1 === r2 ? 1 : 0;
  r2 = r4 === r3 ? 1 : 0;
  r1 = r1 & r2;

  r2 = r4 === r5 ? 1 : 0;
  r1 = r1 | r2;
  r2 = (r0 + 1) | 0;
  r1 = r1 !== 0 ? r2 : r0;
  r2 = heapClassInst.heapU8[r1];
  r3 = heapClassInst.heap32[fp + 1];
  repeat1: do {
    if (r2 !== 0) {
      r4 = sp + numDefineNeg2048;
      r1 = (r1 + 1) | 0;
      r6 = 0;
      r8 = numDefine26;
      repeat3: while (true) {
        r7 = r2 & numDefine255;
        if (r7 === numDefine47) {
          label = numDefine5;
        } else {
          if (r7 !== numDefine92) {
            r6 = r2 << numDefine24;
            r6 = r6 >> numDefine24;
            r7 = (r6 + numDefineNeg65) | 0;
            r9 = (r2 + numDefine32) | 0;
            r10 = (r4 + 1) | 0;
            r6 = 0;
            r2 = uint(r7) < uint(r8) ? r9 : r2;
            heapClassInst.heap8[r4] = r2;
            r4 = r10;
            label = numDefine9;
          } else {
            label = numDefine5;
          }
        }
        if (label === numDefine5) {
          r2 = r6 & numDefine255;
          heapClassInst.heap8[r4] = r5;
          if (r2 === 0) {
            r4 = (r4 + 1) | 0;
            r6 = 1;
          } else {
            r6 = 1;
          }
        }
        r2 = heapClassInst.heapU8[r1];
        if (r2 !== 0) {
          r1 = (r1 + 1) | 0;
          continue repeat3;
        } else {
          break repeat1;
        }
      }
    } else {
      r4 = sp + numDefineNeg2048;
    }
  } while (false);
  r1 = 0;
  heapClassInst.heap8[r4] = r1;
  r2 = sp + numDefineNeg2048;
  r4 = twoEStr33679;
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = numDefine4;
  strncmp(i7);
  r4 = commonVariable.rg0;
  repeat17: do {
    if (r4 !== 0) {
      r4 = twoEStr34680;
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = numDefine4;
      strncmp(i7);
      r4 = commonVariable.rg0;
      if (r4 === 0) {
        heapClassInst.heap32[g0] = 0;
        z30MandreelFopenEnableCheckfatb(i7);
        r0 = twoEStr31677;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        strcmp(i7);
        r0 = commonVariable.rg0;
        repeat21: do {
          if (r0 !== 0) {
            r0 = twoEStr4651;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r0;
            strcmp(i7);
            r0 = commonVariable.rg0;
            if (r0 === 0) {
              label = numDefine30;
            } else {
              r0 = twoEStr5652;
              heapClassInst.heap32[g0] = r3;
              heapClassInst.heap32[g0 + 1] = r0;
              strcmp(i7);
              r0 = commonVariable.rg0;
              if (r0 !== 0) {
                r0 = twoEStr32678;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r0;
                strcmp(i7);
                r0 = commonVariable.rg0;
                if (!(r0 === 0)) {
                  r4 = heapClassInst.heapU8[r3];
                  r0 = numDefine119;
                  r3 = numDefine114;

                  r0 = r4 === r0 ? 1 : 0;
                  r5 = r4 === r3 ? 1 : 0;
                  r3 = r0 & 1;
                  r0 = r5 & 1;
                  if (r4 === numDefine114) {
                    label = numDefine36;
                    break repeat21;
                  } else {
                    label = numDefine38;
                    break repeat21;
                  }
                }
              }
              r0 = 1;
              r1 = 0;
              r3 = r0;
              label = numDefine38;
            }
          } else {
            label = numDefine30;
          }
        } while (false);
        if (label === numDefine30) {
          r0 = 1;
          r3 = r0;
          label = numDefine36;
        }
        if (label === numDefine36) {
          heapClassInst.heap32[g0] = r2;
          mandreelOpencloud(i7);
          r1 = commonVariable.rg0;
          if (r1 === -1) {
            r4 = 0;
            break repeat17;
          }
        }
        heapClassInst.heap32[g0] = numDefine284;
        znwj(i7);
        r4 = commonVariable.rg0;
        r5 = ztv10CFileCloud;
        r6 = r4 >> numDefine2;
        r5 = (r5 + numDefine8) | 0;
        r7 = 1;
        heapClassInst.heap32[r6] = r5;
        heapClassInst.heap8[r4 + numDefine4] = r7;
        heapClassInst.heap32[r6 + numDefine4] = 0;
        heapClassInst.heap32[r6 + numDefine6] = 0;
        heapClassInst.heap32[r6 + numDefine2] = r1;
        heapClassInst.heap8[r4 + numDefine5] = r3;
        heapClassInst.heap8[r4 + numDefine6] = r0;
        heapClassInst.heap32[r6 + numDefine5] = 0;
        r0 = (r4 + numDefine28) | 0;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        strcpy(i7);
        if (r1 === 0) {
          r0 = r3 & numDefine255;
          if (r0 === 0) {
            break repeat17;
          } else {
            r0 = r4 >> numDefine2;
            heapClassInst.heap32[r0 + numDefine3] = numDefine31072;
            heapClassInst.heap32[g0] = numDefine31072;
            mallocNew(i7);
            heapClassInst.heap32[r0 + numDefine6] = commonVariable.rg0;
          }
        } else {
          r3 = (r1 + numDefine31072) | 0;
          r2 = r4 >> numDefine2;
          heapClassInst.heap32[r2 + numDefine3] = r3;
          heapClassInst.heap32[g0] = r3;
          mallocNew(i7);
          heapClassInst.heap32[r2 + numDefine6] = commonVariable.rg0;
          r3 = (r1 + numDefine4) | 0;
          heapClassInst.heap32[g0] = r3;
          mallocNew(i7);
          r3 = commonVariable.rg0;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r3;
          heapClassInst.heap32[g0 + numDefine2] = r1;
          mandreelReadcloud(i7);
          r0 = heapClassInst.heap32[r2 + numDefine3];
          r5 = heapClassInst.heap32[r2 + numDefine6];
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = r5;
          heapClassInst.heap32[g0 + numDefine3] = r0;
          zn12mandreelB6410b64DecodeEPKcjPvj(i7);
          r0 = commonVariable.rg0;
          heapClassInst.heap32[g0] = r3;
          free(i7);
          heapClassInst.heap32[r2 + numDefine2] = r0;
          heapClassInst.heap32[r2 + numDefine5] = r0;
        }
      } else {
        r1 = r3;
        repeat39: while (true) {
          r4 = heapClassInst.heapU8[r1];
          if (r4 === 0) {
            label = numDefine46;
            break repeat39;
          } else {
            if (r4 === numDefine87) {
              label = numDefine45;
              break repeat39;
            } else {
              r1 = (r1 + 1) | 0;
              if (r4 !== numDefine119) {
                label = numDefine42;
              } else {
                label = numDefine45;
                break repeat39;
              }
            }
          }
        }
        switch (label) {
          case numDefine46:
            r0 = heapClassInst.heapU8[sp + numDefineNeg2048];
            if (r0 !== numDefine47) {
              heapClassInst.heap32[g0] = r2;
              heapClassInst.heap32[g0 + 1] = r3;
              mandreelFopen(i7);
              r2 = commonVariable.rg0;
            } else {
              r2 = (r2 + 1) | 0;
              heapClassInst.heap32[g0] = r2;
              heapClassInst.heap32[g0 + 1] = r3;
              mandreelFopen(i7);
              r2 = commonVariable.rg0;
            }
            if (r2 === 0) {
              r0 = 0;
              commonVariable.rg0 = r0;
              return;
            } else {
              heapClassInst.heap32[g0] = numDefine8;
              r0 = ztv11CFileSystem;
              znwj(i7);
              r3 = commonVariable.rg0 >> numDefine2;
              r0 = (r0 + numDefine8) | 0;
              heapClassInst.heap32[r3] = r0;
              heapClassInst.heap32[r3 + 1] = r2;
              return;
            }
          case numDefine45:
            r2 = twoEStr35681;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            printf(i7);
            r2 = 0;
            commonVariable.rg0 = r2;
            return;
          default:
            break;
        }
      }
    } else {
      heapClassInst.heap32[g0] = 0;
      z30MandreelFopenEnableCheckfatb(i7);
      r0 = twoEStr31677;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r0;
      strcmp(i7);
      r0 = commonVariable.rg0;
      repeat54: do {
        if (r0 !== 0) {
          r0 = twoEStr4651;
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r0;
          strcmp(i7);
          r0 = commonVariable.rg0;
          if (r0 === 0) {
            label = numDefine13;
          } else {
            r0 = twoEStr5652;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r0;
            strcmp(i7);
            r0 = commonVariable.rg0;
            if (r0 !== 0) {
              r0 = twoEStr32678;
              heapClassInst.heap32[g0] = r3;
              heapClassInst.heap32[g0 + 1] = r0;
              strcmp(i7);
              r0 = commonVariable.rg0;
              if (!(r0 === 0)) {
                r3 = heapClassInst.heapU8[r3];
                r0 = numDefine119;
                r1 = numDefine114;

                r0 = r3 === r0 ? 1 : 0;
                r4 = r3 === r1 ? 1 : 0;
                r1 = r0 & 1;
                r0 = r4 & 1;
                if (r3 === numDefine114) {
                  label = numDefine20;
                  break repeat54;
                } else {
                  r3 = 0;
                  label = numDefine22;
                  break repeat54;
                }
              }
            }
            r0 = 1;
            r3 = 0;
            r1 = r0;
            label = numDefine22;
          }
        } else {
          label = numDefine13;
        }
      } while (false);
      if (label === numDefine13) {
        r0 = 1;
        r1 = r0;
        label = numDefine20;
      }
      if (label === numDefine20) {
        heapClassInst.heap32[g0] = r2;
        mandreelOpenls(i7);
        r3 = commonVariable.rg0;
        if (r3 === -1) {
          r4 = 0;
          break repeat17;
        }
      }
      heapClassInst.heap32[g0] = numDefine284;
      znwj(i7);
      r4 = commonVariable.rg0;
      r5 = ztv7CFileLS;
      r6 = r4 >> numDefine2;
      r5 = (r5 + numDefine8) | 0;
      r7 = 1;
      heapClassInst.heap32[r6] = r5;
      heapClassInst.heap8[r4 + numDefine4] = r7;
      heapClassInst.heap32[r6 + numDefine4] = 0;
      heapClassInst.heap32[r6 + numDefine6] = 0;
      heapClassInst.heap32[r6 + numDefine2] = r3;
      heapClassInst.heap8[r4 + numDefine5] = r1;
      heapClassInst.heap8[r4 + numDefine6] = r0;
      heapClassInst.heap32[r6 + numDefine5] = 0;
      r0 = (r4 + numDefine28) | 0;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r2;
      strcpy(i7);
      if (r3 === 0) {
        r0 = r1 & numDefine255;
        if (!(r0 === 0)) {
          r0 = r4 >> numDefine2;
          heapClassInst.heap32[r0 + numDefine3] = numDefine31072;
          heapClassInst.heap32[g0] = numDefine31072;
          mallocNew(i7);
          heapClassInst.heap32[r0 + numDefine6] = commonVariable.rg0;
        }
      } else {
        r1 = (r3 + numDefine31072) | 0;
        r2 = r4 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine3] = r1;
        heapClassInst.heap32[g0] = r1;
        mallocNew(i7);
        heapClassInst.heap32[r2 + numDefine6] = commonVariable.rg0;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        mandreelReadls(i7);
        heapClassInst.heap32[r2 + numDefine5] = r3;
      }
    }
  } while (false);
  heapClassInst.heap32[g0] = 1;
  z30MandreelFopenEnableCheckfatb(i7);
  commonVariable.rg0 = r4;
  return;
}

function floatundidf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 | r1;
  if (r2 === 0) {
    f0 = 0;
    commonVariable.fg0 = f0;
    return;
  } else {
    r2 = r0 >>> 1;
    r3 = r1 >>> 1;
    r2 = r0 | r2;
    r3 = r1 | r3;
    r4 = r2 >>> numDefine2;
    r5 = r3 >>> numDefine2;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 >>> numDefine4;
    r5 = r3 >>> numDefine4;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 >>> numDefine8;
    r5 = r3 >>> numDefine8;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 >>> numDefine16;
    r5 = r3 >>> numDefine16;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 ^ -1;
    r5 = numDefine55765;
    r6 = r3 ^ -1;
    r4 = r4 >>> 1;
    r6 = r6 >>> 1;
    r2 = r5 & ~r2;
    r4 = r4 & numDefine55765;
    r2 = (r2 + r4) | 0;
    r3 = r5 & ~r3;
    r4 = r6 & numDefine55765;
    r3 = (r3 + r4) | 0;
    r4 = r2 >>> numDefine2;
    r5 = r3 >>> numDefine2;
    r2 = r2 & numDefine93459;
    r4 = r4 & numDefine93459;
    r2 = (r2 + r4) | 0;
    r3 = r3 & numDefine93459;
    r4 = r5 & numDefine93459;
    r3 = (r3 + r4) | 0;
    r4 = r2 >>> numDefine4;
    r5 = r3 >>> numDefine4;
    r2 = r2 & numDefine45135;
    r4 = r4 & numDefine45135;
    r2 = (r2 + r4) | 0;
    r3 = r3 & numDefine45135;
    r4 = r5 & numDefine45135;
    r3 = (r3 + r4) | 0;
    r4 = r2 >>> numDefine8;
    r5 = r3 >>> numDefine8;
    r2 = r2 & numDefine11935;
    r4 = r4 & numDefine11935;
    r2 = (r2 + r4) | 0;
    r3 = r3 & numDefine11935;
    r4 = r5 & numDefine11935;
    r3 = (r3 + r4) | 0;
    r4 = r2 & numDefine65535;
    r2 = r2 >>> numDefine16;
    r2 = (r4 + r2) | 0;
    r4 = r3 & numDefine65535;
    r3 = r3 >>> numDefine16;
    r3 = (r4 + r3) | 0;
    r2 = (r2 + numDefine32) | 0;
    r4 = numDefine64;
    r2 = r1 !== 0 ? r3 : r2;
    r3 = numDefine63;
    r4 = (r4 - r2) | 0;
    r2 = (r3 - r2) | 0;
    if (r4 < numDefine54) {
      r3 = numDefine53;
      r3 = (r3 - r4) | 0;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r3;
      ashldi3(i7);
      r3 = commonVariable.rg0;
      r1 = commonVariable.rg1;
    } else {
      if (r4 === numDefine54) {
        r1 = r1 << 1;
        r3 = r0 >>> numDefine31;
        r0 = r0 << 1;
        r1 = r1 | r3;
      } else {
        if (r4 !== numDefine55) {
          r3 = (r4 + numDefineNeg55) | 0;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = r3;
          lshrdi3(i7);
          r3 = commonVariable.rg0;
          r5 = commonVariable.rg1;
          r6 = numDefine119;
          r6 = (r6 - r4) | 0;
          heapClassInst.heap32[g0] = -1;
          heapClassInst.heap32[g0 + 1] = -1;
          heapClassInst.heap32[g0 + numDefine2] = r6;
          lshrdi3(i7);
          r0 = commonVariable.rg0 & r0;
          r1 = commonVariable.rg1 & r1;
          r0 = r0 | r1;
          r1 = 0;

          r0 = r0 !== r1 ? 1 : 0;
          r0 = r0 & 1;
          r0 = r0 | r3;
          r1 = r5;
        }
      }
      r3 = r0 >>> numDefine2;
      r3 = r3 & 1;
      r0 = r3 | r0;
      r3 = (r0 + 1) | 0;
      r5 = 1;
      r6 = 0;
      r0 = uint(r3) < uint(r0) ? r5 : r6;
      r0 = r3 === 0 ? r5 : r0;
      r0 = (r1 + r0) | 0;
      r1 = r0 >>> numDefine2;
      r5 = r1 & numDefine97152;
      if (r5 !== 0) {
        r1 = r3 >>> numDefine3;
        r2 = r0 << numDefine29;
        r3 = r1 | r2;
        r1 = r0 >>> numDefine3;
        r2 = r4;
      } else {
        r3 = r3 >>> numDefine2;
        r0 = r0 << numDefine30;
        r3 = r3 | r0;
      }
    }
    r0 = r2 << numDefine20;
    r2 = sp + numDefineNeg8;
    r1 = r1 & numDefine48575;
    r0 = (r0 + numDefine93248) | 0;
    r2 = r2 >> numDefine2;
    r0 = r1 | r0;
    heapClassInst.heap32[fp + numDefineNeg2] = r3;
    heapClassInst.heap32[r2 + 1] = r0;
    f0 = llvmReadDouble(sp + numDefineNeg8);
    commonVariable.fg0 = f0;
    return;
  }
}

function udivmoddi4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp + numDefine4];
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[fp + numDefine3];
  repeat1: do {
    if (r0 !== 0) {
      repeat3: do {
        if (r3 !== 0) {
          if (r4 !== 0) {
            r5 = r4 >>> 1;
            r6 = r0 >>> 1;
            r5 = r4 | r5;
            r6 = r0 | r6;
            r7 = r5 >>> numDefine2;
            r9 = r6 >>> numDefine2;
            r5 = r5 | r7;
            r6 = r6 | r9;
            r7 = r5 >>> numDefine4;
            r9 = r6 >>> numDefine4;
            r5 = r5 | r7;
            r6 = r6 | r9;
            r7 = r5 >>> numDefine8;
            r9 = r6 >>> numDefine8;
            r5 = r5 | r7;
            r6 = r6 | r9;
            r7 = r5 >>> numDefine16;
            r9 = r6 >>> numDefine16;
            r5 = r5 | r7;
            r6 = r6 | r9;
            r7 = r5 ^ -1;
            r9 = r6 ^ -1;
            r8 = numDefine55765;
            r7 = r7 >>> 1;
            r9 = r9 >>> 1;
            r5 = r8 & ~r5;
            r7 = r7 & numDefine55765;
            r6 = r8 & ~r6;
            r9 = r9 & numDefine55765;
            r5 = (r5 + r7) | 0;
            r6 = (r6 + r9) | 0;
            r7 = r5 >>> numDefine2;
            r9 = r6 >>> numDefine2;
            r5 = r5 & numDefine93459;
            r7 = r7 & numDefine93459;
            r6 = r6 & numDefine93459;
            r9 = r9 & numDefine93459;
            r5 = (r5 + r7) | 0;
            r6 = (r6 + r9) | 0;
            r7 = r5 >>> numDefine4;
            r9 = r6 >>> numDefine4;
            r5 = r5 & numDefine45135;
            r7 = r7 & numDefine45135;
            r6 = r6 & numDefine45135;
            r9 = r9 & numDefine45135;
            r5 = (r5 + r7) | 0;
            r6 = (r6 + r9) | 0;
            r7 = r5 >>> numDefine8;
            r9 = r6 >>> numDefine8;
            r5 = r5 & numDefine11935;
            r7 = r7 & numDefine11935;
            r6 = r6 & numDefine11935;
            r9 = r9 & numDefine11935;
            r5 = (r5 + r7) | 0;
            r6 = (r6 + r9) | 0;
            r7 = r5 & numDefine65535;
            r5 = r5 >>> numDefine16;
            r9 = r6 & numDefine65535;
            r6 = r6 >>> numDefine16;
            r5 = (r7 + r5) | 0;
            r6 = (r9 + r6) | 0;
            r5 = (r5 - r6) | 0;
            if (uint(r5) < uint(numDefine32)) {
              r6 = numDefine31;
              r7 = (r5 + 1) | 0;
              r9 = (r5 + numDefineNeg31) | 0;
              r5 = (r6 - r5) | 0;
              r6 = r2 >>> r7;
              r8 = r9 >> numDefine31;
              r10 = r0 >>> r7;
              r6 = r6 & r8;
              r0 = r0 << r5;
              r9 = 0;
              r2 = r2 << r5;
              r5 = r6 | r0;
              r6 = r10 & r8;
              label = numDefine39;
              break repeat3;
            } else {
              if (r1 === 0) {
                label = numDefine7;
                break repeat1;
              } else {
                r5 = r1 >> numDefine2;
                heapClassInst.heap32[r5] = r2;
                heapClassInst.heap32[r5 + 1] = r0;
                r2 = 0;
                commonVariable.rg0 = r2;
                commonVariable.rg1 = r2;
                return;
              }
            }
          } else {
            r5 = (r3 + -1) | 0;
            r6 = r5 & r3;
            if (r6 !== 0) {
              r5 = r3 >>> 1;
              r6 = r0 >>> 1;
              r5 = r3 | r5;
              r6 = r0 | r6;
              r7 = r5 >>> numDefine2;
              r9 = r6 >>> numDefine2;
              r5 = r5 | r7;
              r6 = r6 | r9;
              r7 = r5 >>> numDefine4;
              r9 = r6 >>> numDefine4;
              r5 = r5 | r7;
              r6 = r6 | r9;
              r7 = r5 >>> numDefine8;
              r9 = r6 >>> numDefine8;
              r5 = r5 | r7;
              r6 = r6 | r9;
              r7 = r5 >>> numDefine16;
              r9 = r6 >>> numDefine16;
              r5 = r5 | r7;
              r6 = r6 | r9;
              r7 = r5 ^ -1;
              r9 = r6 ^ -1;
              r8 = numDefine55765;
              r7 = r7 >>> 1;
              r9 = r9 >>> 1;
              r5 = r8 & ~r5;
              r7 = r7 & numDefine55765;
              r6 = r8 & ~r6;
              r9 = r9 & numDefine55765;
              r5 = (r5 + r7) | 0;
              r6 = (r6 + r9) | 0;
              r7 = r5 >>> numDefine2;
              r9 = r6 >>> numDefine2;
              r5 = r5 & numDefine93459;
              r7 = r7 & numDefine93459;
              r6 = r6 & numDefine93459;
              r9 = r9 & numDefine93459;
              r5 = (r5 + r7) | 0;
              r6 = (r6 + r9) | 0;
              r7 = r5 >>> numDefine4;
              r9 = r6 >>> numDefine4;
              r5 = r5 & numDefine45135;
              r7 = r7 & numDefine45135;
              r6 = r6 & numDefine45135;
              r9 = r9 & numDefine45135;
              r5 = (r5 + r7) | 0;
              r6 = (r6 + r9) | 0;
              r7 = r5 >>> numDefine8;
              r9 = r6 >>> numDefine8;
              r5 = r5 & numDefine11935;
              r7 = r7 & numDefine11935;
              r6 = r6 & numDefine11935;
              r9 = r9 & numDefine11935;
              r5 = (r5 + r7) | 0;
              r6 = (r6 + r9) | 0;
              r7 = r5 & numDefine65535;
              r5 = r5 >>> numDefine16;
              r9 = r6 & numDefine65535;
              r6 = r6 >>> numDefine16;
              r5 = (r7 + r5) | 0;
              r6 = (r9 + r6) | 0;
              r5 = (r5 - r6) | 0;
              r6 = numDefine31;
              r7 = (r5 + numDefine33) | 0;
              r9 = r5 ^ -1;
              r8 = (r5 + 1) | 0;
              r6 = (r6 - r5) | 0;
              r10 = numDefineNeg2;
              r10 = (r10 - r5) | 0;
              r11 = r0 << r6;
              r12 = r2 >>> r8;
              r13 = r2 >>> r7;
              r14 = r0 << r9;
              r11 = r11 | r12;
              r12 = r9 >> numDefine31;
              r9 = r2 << r9;
              r5 = r5 >> numDefine31;
              r13 = r13 | r14;
              r14 = r8 >> numDefine31;
              r8 = r0 >>> r8;
              r10 = r10 >> numDefine31;
              r2 = r2 << r6;
              r0 = r0 >>> r7;
              r6 = r11 & r12;
              r5 = r9 & r5;
              r11 = r13 & r14;
              r8 = r8 & r10;
              r9 = r2 & r12;
              r2 = r6 | r5;
              r5 = r11 | r8;
              r6 = r0 & r14;
              if (r7 === 0) {
                r0 = 0;
                r3 = r0;
                label = numDefine42;
                break repeat3;
              } else {
                label = numDefine39;
                break repeat3;
              }
            } else {
              if (!(r1 === 0)) {
                r1 = r1 >> numDefine2;
                r4 = r5 & r2;
                heapClassInst.heap32[r1] = r4;
                heapClassInst.heap32[r1 + 1] = 0;
              }
              if (r3 !== 1) {
                r1 = r5 & ~r3;
                r3 = r1 >>> 1;
                r1 = r1 & numDefine55765;
                r3 = r3 & numDefine55765;
                r1 = (r1 + r3) | 0;
                r3 = r1 >>> numDefine2;
                r1 = r1 & numDefine93459;
                r3 = r3 & numDefine93459;
                r1 = (r1 + r3) | 0;
                r3 = r1 >>> numDefine4;
                r1 = r1 & numDefine45135;
                r3 = r3 & numDefine45135;
                r1 = (r1 + r3) | 0;
                r3 = r1 >>> numDefine8;
                r1 = r1 & numDefine11935;
                r3 = r3 & numDefine11935;
                r1 = (r1 + r3) | 0;
                r3 = r1 & numDefine65535;
                r1 = r1 >>> numDefine16;
                r1 = (r3 + r1) | 0;
                r3 = numDefine32;
                r3 = (r3 - r1) | 0;
                r3 = r0 << r3;
                r2 = r2 >>> r1;
                r2 = r3 | r2;
                r0 = r0 >>> r1;
                label = numDefine44;
                break repeat1;
              } else {
                label = numDefine44;
                break repeat1;
              }
            }
          }
        } else {
          if (r4 !== 0) {
            if (r2 !== 0) {
              r5 = (r4 + -1) | 0;
              r6 = r5 & r4;
              if (r6 !== 0) {
                r5 = r4 >>> 1;
                r6 = r0 >>> 1;
                r5 = r4 | r5;
                r6 = r0 | r6;
                r7 = r5 >>> numDefine2;
                r8 = r6 >>> numDefine2;
                r5 = r5 | r7;
                r6 = r6 | r8;
                r7 = r5 >>> numDefine4;
                r8 = r6 >>> numDefine4;
                r5 = r5 | r7;
                r6 = r6 | r8;
                r7 = r5 >>> numDefine8;
                r8 = r6 >>> numDefine8;
                r5 = r5 | r7;
                r6 = r6 | r8;
                r7 = r5 >>> numDefine16;
                r8 = r6 >>> numDefine16;
                r5 = r5 | r7;
                r6 = r6 | r8;
                r7 = r5 ^ -1;
                r8 = r6 ^ -1;
                r9 = numDefine55765;
                r7 = r7 >>> 1;
                r8 = r8 >>> 1;
                r5 = r9 & ~r5;
                r7 = r7 & numDefine55765;
                r6 = r9 & ~r6;
                r8 = r8 & numDefine55765;
                r5 = (r5 + r7) | 0;
                r6 = (r6 + r8) | 0;
                r7 = r5 >>> numDefine2;
                r8 = r6 >>> numDefine2;
                r5 = r5 & numDefine93459;
                r7 = r7 & numDefine93459;
                r6 = r6 & numDefine93459;
                r8 = r8 & numDefine93459;
                r5 = (r5 + r7) | 0;
                r6 = (r6 + r8) | 0;
                r7 = r5 >>> numDefine4;
                r8 = r6 >>> numDefine4;
                r5 = r5 & numDefine45135;
                r7 = r7 & numDefine45135;
                r6 = r6 & numDefine45135;
                r8 = r8 & numDefine45135;
                r5 = (r5 + r7) | 0;
                r6 = (r6 + r8) | 0;
                r7 = r5 >>> numDefine8;
                r8 = r6 >>> numDefine8;
                r5 = r5 & numDefine11935;
                r7 = r7 & numDefine11935;
                r6 = r6 & numDefine11935;
                r8 = r8 & numDefine11935;
                r5 = (r5 + r7) | 0;
                r6 = (r6 + r8) | 0;
                r7 = r5 & numDefine65535;
                r5 = r5 >>> numDefine16;
                r8 = r6 & numDefine65535;
                r6 = r6 >>> numDefine16;
                r5 = (r7 + r5) | 0;
                r6 = (r8 + r6) | 0;
                r5 = (r5 - r6) | 0;
                if (uint(r5) < uint(numDefine31)) {
                  r6 = numDefine31;
                  r7 = (r5 + 1) | 0;
                  r5 = (r6 - r5) | 0;
                  r6 = r0 << r5;
                  r8 = r2 >>> r7;
                  r9 = 0;
                  r2 = r2 << r5;
                  r5 = r6 | r8;
                  r6 = r0 >>> r7;
                  label = numDefine39;
                  break repeat3;
                } else {
                  if (r1 === 0) {
                    label = numDefine7;
                    break repeat1;
                  } else {
                    r1 = r1 >> numDefine2;
                    heapClassInst.heap32[r1] = r2;
                    heapClassInst.heap32[r1 + 1] = r0;
                    label = numDefine9;
                    break repeat1;
                  }
                }
              } else {
                if (!(r1 === 0)) {
                  r1 = r1 >> numDefine2;
                  r3 = r5 & r0;
                  heapClassInst.heap32[r1] = r2;
                  heapClassInst.heap32[r1 + 1] = r3;
                }
                r1 = (r4 + -1) | 0;
                r1 = r1 & ~r4;
                r2 = r1 >>> 1;
                r1 = r1 & numDefine55765;
                r2 = r2 & numDefine55765;
                r1 = (r1 + r2) | 0;
                r2 = r1 >>> numDefine2;
                r1 = r1 & numDefine93459;
                r2 = r2 & numDefine93459;
                r1 = (r1 + r2) | 0;
                r2 = r1 >>> numDefine4;
                r1 = r1 & numDefine45135;
                r2 = r2 & numDefine45135;
                r1 = (r1 + r2) | 0;
                r2 = r1 >>> numDefine8;
                r1 = r1 & numDefine11935;
                r2 = r2 & numDefine11935;
                r1 = (r1 + r2) | 0;
                r2 = r1 & numDefine65535;
                r1 = r1 >>> numDefine16;
                r1 = (r2 + r1) | 0;
                r0 = r0 >>> r1;
                label = numDefine5;
                break repeat1;
              }
            } else {
              if (!(r1 === 0)) {
                r1 = r1 >> numDefine2;
                r2 = Math.floor(uint(r0) % uint(r4));
                heapClassInst.heap32[r1] = 0;
                heapClassInst.heap32[r1 + 1] = r2;
              }
              r0 = Math.floor(uint(r0) / uint(r4));
              label = numDefine5;
              break repeat1;
            }
          } else {
            if (!(r1 === 0)) {
              r1 = r1 >> numDefine2;
              r2 = Math.floor(uint(r0) % uint(r3));
              heapClassInst.heap32[r1] = r2;
              heapClassInst.heap32[r1 + 1] = 0;
            }
            r0 = Math.floor(uint(r0) / uint(r3));
            label = numDefine5;
            break repeat1;
          }
        }
      } while (false);
      if (label === numDefine39) {
        r8 = (r3 + -1) | 0;
        r10 = 0;
        r11 = 1;
        r0 = uint(r8) < uint(r3) ? r11 : r10;
        r0 = r3 !== 0 ? r11 : r0;
        r0 = (r4 + r0) | 0;
        r12 = (r0 + -1) | 0;
        r13 = r10;
        repeat45: while (true) {
          r0 = r5 << 1;
          r14 = r2 >>> numDefine31;
          r6 = r6 << 1;
          r5 = r5 >>> numDefine31;
          r14 = r0 | r14;
          r0 = r6 | r5;
          r5 = (r12 - r0) | 0;
          r6 = uint(r8) < uint(r14) ? r11 : r10;
          r5 = (r5 - r6) | 0;
          r5 = r5 >> numDefine31;
          r6 = r5 & r3;
          r15 = r5 & r4;
          r16 = r9 << 1;
          r2 = r2 << 1;
          r17 = r9 >>> numDefine31;
          r15 = (r0 - r15) | 0;
          r18 = uint(r14) < uint(r6) ? r11 : r10;
          r7 = (r7 + -1) | 0;
          r0 = r5 & 1;
          r9 = r13 | r16;
          r2 = r2 | r17;
          r5 = (r14 - r6) | 0;
          r6 = (r15 - r18) | 0;
          r13 = r0;
          if (!(r7 !== 0)) {
            break repeat45;
          }
        }
        r3 = 0;
      }
      r2 = r2 << 1;
      r4 = r9 >>> numDefine31;
      r7 = r9 << 1;
      r4 = r2 | r4;
      r2 = r0 | r7;
      r0 = r3 | r4;
      if (r1 !== 0) {
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1] = r5;
        heapClassInst.heap32[r1 + 1] = r6;
        label = numDefine44;
        break repeat1;
      } else {
        label = numDefine44;
        break repeat1;
      }
    } else {
      if (r4 !== 0) {
        if (r1 !== 0) {
          r0 = r1 >> numDefine2;
          heapClassInst.heap32[r0] = r2;
          heapClassInst.heap32[r0 + 1] = 0;
          label = numDefine9;
          break repeat1;
        } else {
          label = numDefine7;
          break repeat1;
        }
      } else {
        if (!(r1 === 0)) {
          r0 = r1 >> numDefine2;
          r1 = Math.floor(uint(r2) % uint(r3));
          heapClassInst.heap32[r0] = r1;
          heapClassInst.heap32[r0 + 1] = 0;
        }
        r0 = Math.floor(uint(r2) / uint(r3));
        label = numDefine5;
      }
    }
  } while (false);
  switch (label) {
    case numDefine7:
      r2 = 0;
      r0 = r2;
      break;
    case numDefine9:
      r0 = 0;
      commonVariable.rg0 = r0;
      commonVariable.rg1 = r0;
      return;
    case numDefine5:
      r1 = 0;
      commonVariable.rg0 = r0;
      commonVariable.rg1 = r1;
      return;
    default:
      break;
  }
  commonVariable.rg0 = r2;
  commonVariable.rg1 = r0;
  return;
}

function umoddi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg8;
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  heapClassInst.heap32[g0 + numDefine3] = r4;
  heapClassInst.heap32[g0 + numDefine4] = r0;
  udivmoddi4(i7);
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefineNeg2];
  r0 = heapClassInst.heap32[r0 + 1];
  commonVariable.rg0 = r1;
  commonVariable.rg1 = r0;
  return;
}

function moddi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 >> numDefine31;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = r1 >> numDefine31;
  r5 = heapClassInst.heap32[fp];
  r1 = r4 ^ r1;
  r5 = r4 ^ r5;
  r0 = r2 ^ r0;
  r3 = r2 ^ r3;
  r6 = 1;
  r7 = 0;
  r1 = (r1 - r4) | 0;
  r8 = uint(r5) < uint(r4) ? r6 : r7;
  r0 = (r0 - r2) | 0;
  r9 = uint(r3) < uint(r2) ? r6 : r7;
  r10 = sp + numDefineNeg8;
  r5 = (r5 - r4) | 0;
  r1 = (r1 - r8) | 0;
  r2 = (r3 - r2) | 0;
  r0 = (r0 - r9) | 0;
  heapClassInst.heap32[g0] = r5;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  heapClassInst.heap32[g0 + numDefine4] = r10;
  udivmoddi4(i7);
  r0 = r10 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[fp + numDefineNeg2];
  r1 = r1 ^ r4;
  r0 = r0 ^ r4;
  r0 = (r0 - r4) | 0;
  r2 = uint(r1) < uint(r4) ? r6 : r7;
  r1 = (r1 - r4) | 0;
  r0 = (r0 - r2) | 0;
  commonVariable.rg0 = r1;
  commonVariable.rg1 = r0;
  return;
}

function divdi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r1 >> numDefine31;
  r3 = heapClassInst.heap32[fp];
  r4 = r0 >> numDefine31;
  r5 = heapClassInst.heap32[fp + numDefine2];
  r6 = r2 ^ r1;
  r3 = r2 ^ r3;
  r7 = r4 ^ r0;
  r5 = r4 ^ r5;
  r8 = 1;
  r9 = 0;
  r6 = (r6 - r2) | 0;
  r10 = uint(r3) < uint(r2) ? r8 : r9;
  r7 = (r7 - r4) | 0;
  r11 = uint(r5) < uint(r4) ? r8 : r9;
  r2 = (r3 - r2) | 0;
  r3 = (r6 - r10) | 0;
  r4 = (r5 - r4) | 0;
  r5 = (r7 - r11) | 0;
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  heapClassInst.heap32[g0 + numDefine3] = r5;
  heapClassInst.heap32[g0 + numDefine4] = 0;
  r0 = r0 ^ r1;
  udivmoddi4(i7);
  r0 = r0 >> numDefine31;
  r1 = commonVariable.rg0 ^ r0;
  r2 = commonVariable.rg1 ^ r0;
  r2 = (r2 - r0) | 0;
  r3 = uint(r1) < uint(r0) ? r8 : r9;
  r0 = (r1 - r0) | 0;
  r1 = (r2 - r3) | 0;
  commonVariable.rg0 = r0;
  commonVariable.rg1 = r1;
  return;
}

function udivdi3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  heapClassInst.heap32[g0 + numDefine4] = 0;
  udivmoddi4(i7);
  return;
}

function sscanf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = (sp + numDefine4) | 0;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[fp + numDefineNeg5] = r0;
  heapClassInst.heap32[fp + numDefineNeg4] = r1;
  heapClassInst.heap32[fp + -1] = r0;
  r0 = sp + numDefineNeg16;
  heapClassInst.heap32[g0] = r0;
  r1 = 1;
  r2 = 0;
  r3 = twoEStr7136;
  sgetc(i7);
  r4 = commonVariable.rg0;
  f3 = numDefine10;
  r20 = numDefine255;
  repeat1: while (true) {
    r5 = heapClassInst.heapU8[r3];
    if (r5 !== 0) {
      r5 = r5 << numDefine24;
      r5 = r5 >> numDefine24;
      r6 = (r3 + 1) | 0;
      if (r5 > numDefine31) {
        if (r5 === numDefine32) {
          label = numDefine7;
        } else {
          if (r5 === numDefine37) {
            r5 = -1;
            r7 = 0;
            r8 = r7;
            r9 = r7;
            r10 = r7;
            r11 = r7;
            repeat8: while (true) {
              r12 = heapClassInst.heap8[r6];
              if (!(r12 === numDefine110)) {
                if (r4 === -1) {
                  label = numDefine168;
                  break repeat1;
                }
              }
              if (r12 > numDefine103) {
                if (r12 > numDefine111) {
                  if (r12 > numDefine114) {
                    label = numDefine40;
                    break repeat8;
                  } else {
                    if (r12 === numDefine112) {
                      label = numDefine52;
                      break repeat8;
                    } else {
                      if (!(r12 === numDefine113)) {
                        label = numDefine168;
                        break repeat1;
                      }
                    }
                  }
                } else {
                  if (r12 > numDefine107) {
                    if (r12 === numDefine108) {
                      r3 = 1;
                      r10 = r10 & numDefine255;
                      r11 = r10 === 0 ? r11 : r3;
                      r6 = (r6 + 1) | 0;
                      r10 = r3;
                      continue repeat8;
                    } else {
                      label = numDefine35;
                      break repeat8;
                    }
                  } else {
                    if (r12 === numDefine104) {
                      r6 = (r6 + 1) | 0;
                      r9 = 1;
                      continue repeat8;
                    } else {
                      label = numDefine33;
                      break repeat8;
                    }
                  }
                }
              } else {
                if (r12 > numDefine75) {
                  if (r12 > numDefine98) {
                    label = numDefine27;
                    break repeat8;
                  } else {
                    if (!(r12 === numDefine76)) {
                      label = numDefine26;
                      break repeat8;
                    }
                  }
                } else {
                  if (r12 > numDefine41) {
                    if (r12 === numDefine42) {
                      r6 = (r6 + 1) | 0;
                      r8 = 1;
                      continue repeat8;
                    } else {
                      r5 = (r12 + numDefineNeg48) | 0;
                      if (uint(r5) < uint(numDefine10)) {
                        r5 = sp + numDefineNeg8;
                        heapClassInst.heap32[g0] = r6;
                        heapClassInst.heap32[g0 + 1] = r5;
                        strtol(i7);
                        r5 = commonVariable.rg0;
                        r6 = heapClassInst.heap32[fp + numDefineNeg2];
                        r7 = 1;
                        continue repeat8;
                      } else {
                        label = numDefine23;
                        break repeat8;
                      }
                    }
                  } else {
                    label = numDefine19;
                    break repeat8;
                  }
                }
              }
              r6 = (r6 + 1) | 0;
              r11 = 1;
            }
            repeat36: do {
              switch (label) {
                case numDefine40:
                  if (r12 === numDefine115) {
                    r8 = r8 & numDefine255;
                    if (!(r8 !== 0)) {
                      r3 = sp + numDefineNeg4;
                      heapClassInst.heap32[g0] = r3;
                      heapClassInst.heap32[g0 + 1] = numDefine4;
                      myArgTest(i7);
                      r3 = commonVariable.rg0 >> numDefine2;
                      r3 = heapClassInst.heap32[r3];
                      heapClassInst.heap32[fp + numDefineNeg2] = r3;
                    }
                    r3 = (r6 + 1) | 0;
                    r6 = r4 << numDefine2;
                    r7 = myCtype;
                    r6 = (r6 + r7) | 0;
                    r6 = heapClassInst.heapU8[r6 + numDefine4];
                    r6 = r6 & numDefine8;
                    repeat43: do {
                      if (r6 === 0) {
                        r6 = r4;
                      } else {
                        while (true) {
                          heapClassInst.heap32[g0] = r0;
                          sgetc(i7);
                          r6 = commonVariable.rg0;
                          r4 = r6 << numDefine2;
                          r4 = (r4 + r7) | 0;
                          r1 = (r1 + 1) | 0;
                          r4 = heapClassInst.heapU8[r4 + numDefine4];
                          r4 = r4 & numDefine8;
                          if (!(r4 !== 0)) {
                            break repeat43;
                          }
                        }
                      }
                    } while (false);
                    r4 = -1;
                    if (r6 === -1) {
                      continue repeat1;
                    } else {
                      r4 = r6;
                      repeat49: while (true) {
                        if (r4 === -1) {
                          break repeat49;
                        } else {
                          if (r5 === 0) {
                            break repeat49;
                          } else {
                            r6 = r4 << numDefine2;
                            r6 = (r6 + r7) | 0;
                            r6 = heapClassInst.heapU8[r6 + numDefine4];
                            r6 = r6 & numDefine8;
                            if (r6 === 0) {
                              if (!(r8 !== 0)) {
                                r6 = heapClassInst.heap32[fp + numDefineNeg2];
                                heapClassInst.heap8[r6] = r4;
                              }
                              if (r4 === 0) {
                                break repeat49;
                              } else {
                                r4 = heapClassInst.heap32[fp + numDefineNeg2];
                                r4 = (r4 + 1) | 0;
                                heapClassInst.heap32[fp + numDefineNeg2] = r4;
                                heapClassInst.heap32[g0] = r0;
                                r1 = (r1 + 1) | 0;
                                r5 = (r5 + -1) | 0;
                                sgetc(i7);
                                r4 = commonVariable.rg0;
                              }
                            } else {
                              break repeat49;
                            }
                          }
                        }
                      }
                      if (r8 !== 0) {
                        continue repeat1;
                      } else {
                        r2 = (r2 + 1) | 0;
                        r5 = heapClassInst.heap32[fp + numDefineNeg2];
                        r6 = 0;
                        heapClassInst.heap8[r5] = r6;
                        continue repeat1;
                      }
                    }
                  } else {
                    if (r12 === numDefine117) {
                      label = numDefine53;
                      break repeat36;
                    } else {
                      if (r12 === numDefine120) {
                        label = numDefine52;
                        break repeat36;
                      } else {
                        label = numDefine168;
                        break repeat1;
                      }
                    }
                  }
                case numDefine35:
                  if (r12 === numDefine110) {
                    r3 = (r6 + 1) | 0;
                    r5 = r8 & numDefine255;
                    if (r5 !== 0) {
                      continue repeat1;
                    } else {
                      r5 = sp + numDefineNeg4;
                      heapClassInst.heap32[g0] = r5;
                      heapClassInst.heap32[g0 + 1] = numDefine4;
                      myArgTest(i7);
                      r5 = commonVariable.rg0 >> numDefine2;
                      r5 = heapClassInst.heap32[r5];
                      r5 = r5 >> numDefine2;
                      r6 = (r1 + -1) | 0;
                      heapClassInst.heap32[r5] = r6;
                      continue repeat1;
                    }
                  } else {
                    if (r12 === numDefine111) {
                      r13 = numDefine8;
                      label = numDefine55;
                      break repeat36;
                    } else {
                      label = numDefine168;
                      break repeat1;
                    }
                  }
                case numDefine33:
                  if (r12 === numDefine105) {
                    label = numDefine53;
                    break repeat36;
                  } else {
                    label = numDefine168;
                    break repeat1;
                  }
                case numDefine27:
                  if (r12 === numDefine99) {
                    r3 = (r6 + 1) | 0;
                    r6 = r8 & numDefine255;
                    if (r6 === 0) {
                      r8 = sp + numDefineNeg4;
                      heapClassInst.heap32[g0] = r8;
                      heapClassInst.heap32[g0 + 1] = numDefine4;
                      myArgTest(i7);
                      r8 = commonVariable.rg0 >> numDefine2;
                      r8 = heapClassInst.heap32[r8];
                      r2 = (r2 + 1) | 0;
                      heapClassInst.heap32[fp + numDefineNeg2] = r8;
                    }
                    r8 = r7 & numDefine255;
                    r7 = 1;
                    r5 = r8 === 0 ? r7 : r5;
                    if (r5 === 0) {
                      continue repeat1;
                    } else {
                      if (r4 === -1) {
                        continue repeat1;
                      } else {
                        r5 = (r5 + -1) | 0;
                        repeat77: while (true) {
                          if (!(r6 !== 0)) {
                            r8 = heapClassInst.heap32[fp + numDefineNeg2];
                            r7 = (r8 + 1) | 0;
                            heapClassInst.heap8[r8] = r4;
                            heapClassInst.heap32[fp + numDefineNeg2] = r7;
                          }
                          heapClassInst.heap32[g0] = r0;
                          r1 = (r1 + 1) | 0;
                          sgetc(i7);
                          r4 = commonVariable.rg0;
                          if (r5 === 0) {
                            continue repeat1;
                          } else {
                            r5 = (r5 + -1) | 0;
                            if (r4 !== -1) {
                              continue repeat77;
                            } else {
                              continue repeat1;
                            }
                          }
                        }
                      }
                    }
                  } else {
                    if (r12 === numDefine100) {
                      r13 = numDefine10;
                      label = numDefine55;
                      break repeat36;
                    } else {
                      r5 = (r12 + numDefineNeg101) | 0;
                      if (uint(r5) < uint(numDefine3)) {
                        label = numDefine46;
                        break repeat36;
                      } else {
                        label = numDefine168;
                        break repeat1;
                      }
                    }
                  }
                case numDefine26:
                  if (r12 === numDefine88) {
                    label = numDefine52;
                    break repeat36;
                  } else {
                    label = numDefine168;
                    break repeat1;
                  }
                case numDefine23:
                  if (r12 === numDefine69) {
                    label = numDefine46;
                    break repeat36;
                  } else {
                    label = numDefine168;
                    break repeat1;
                  }
                case numDefine19:
                  if (r12 === 0) {
                    label = numDefine6;
                    break repeat1;
                  } else {
                    if (r12 === numDefine37) {
                      r5 = r4 & numDefine255;
                      if (r5 !== r12) {
                        label = numDefine168;
                        break repeat1;
                      } else {
                        heapClassInst.heap32[g0] = r0;
                        r1 = (r1 + 1) | 0;
                        r3 = (r6 + 1) | 0;
                        sgetc(i7);
                        r4 = commonVariable.rg0;
                        continue repeat1;
                      }
                    } else {
                      label = numDefine168;
                      break repeat1;
                    }
                  }
                default:
                  break;
              }
            } while (false);
            switch (label) {
              case numDefine53:
                r13 = 0;
                break;
              case numDefine52:
                r13 = numDefine16;
                break;
              case numDefine46:
                r5 = r4 << numDefine2;
                r7 = myCtype;
                r5 = (r5 + r7) | 0;
                r5 = heapClassInst.heapU8[r5 + numDefine4];
                r3 = (r6 + 1) | 0;
                r5 = r5 & numDefine8;
                repeat97: do {
                  if (!(r5 === 0)) {
                    while (true) {
                      heapClassInst.heap32[g0] = r0;
                      sgetc(i7);
                      r4 = commonVariable.rg0;
                      r5 = r4 << numDefine2;
                      r5 = (r5 + r7) | 0;
                      r1 = (r1 + 1) | 0;
                      r5 = heapClassInst.heapU8[r5 + numDefine4];
                      r5 = r5 & numDefine8;
                      if (!(r5 !== 0)) {
                        break repeat97;
                      }
                    }
                  }
                } while (false);
                if (r4 === numDefine45) {
                  heapClassInst.heap32[g0] = r0;
                  r1 = (r1 + 1) | 0;
                  r5 = 1;
                  sgetc(i7);
                  r4 = commonVariable.rg0;
                } else {
                  r5 = 0;
                }
                if (r4 === numDefine43) {
                  heapClassInst.heap32[g0] = r0;
                  r1 = (r1 + 1) | 0;
                  sgetc(i7);
                  r4 = commonVariable.rg0;
                }
                r6 = (r4 + numDefineNeg48) | 0;
                repeat108: do {
                  if (uint(r6) > uint(numDefine9)) {
                    f0 = 0;
                    r6 = r1;
                  } else {
                    f0 = 0;
                    r6 = r1;
                    while (true) {
                      r4 = (r4 + numDefineNeg48) | 0;
                      f1 = numDefine10;
                      heapClassInst.heap32[g0] = r0;
                      f0 = f0 * f1;
                      f1 = r4;
                      sgetc(i7);
                      r4 = commonVariable.rg0;
                      f0 = f0 + f1;
                      r6 = (r6 + 1) | 0;
                      r7 = (r4 + numDefineNeg48) | 0;
                      if (!(uint(r7) < uint(numDefine10))) {
                        break repeat108;
                      }
                    }
                  }
                } while (false);
                repeat114: do {
                  if (r4 === numDefine46) {
                    heapClassInst.heap32[g0] = r0;
                    sgetc(i7);
                    r4 = commonVariable.rg0;
                    r1 = (r1 + 1) | 0;
                    r7 = (r4 + numDefineNeg48) | 0;
                    if (uint(r7) < uint(numDefine10)) {
                      r6 = (r6 + 1) | 0;
                      f1 = numDefineFloat101;
                      while (true) {
                        r4 = (r4 + numDefineNeg48) | 0;
                        f2 = r4;
                        heapClassInst.heap32[g0] = r0;
                        f2 = f2 * f1;
                        sgetc(i7);
                        r4 = commonVariable.rg0;
                        f0 = f2 + f0;
                        f1 = f1 / f3;
                        r6 = (r6 + 1) | 0;
                        r7 = (r4 + numDefineNeg48) | 0;
                        if (!(uint(r7) < uint(numDefine10))) {
                          break repeat114;
                        }
                      }
                    } else {
                      r6 = (r6 + 1) | 0;
                    }
                  }
                } while (false);
                if (r1 === r6) {
                  label = numDefine172;
                  break repeat1;
                } else {
                  r1 = r4 | numDefine32;
                  repeat123: do {
                    if (r1 === numDefine101) {
                      heapClassInst.heap32[g0] = r0;
                      sgetc(i7);
                      r1 = commonVariable.rg0;
                      if (r1 === numDefine45) {
                        heapClassInst.heap32[g0] = r0;
                        f1 = numDefineFloat101;
                        sgetc(i7);
                        r4 = commonVariable.rg0;
                      } else {
                        if (r1 === numDefine43) {
                          heapClassInst.heap32[g0] = r0;
                          f1 = numDefine10;
                          sgetc(i7);
                          r4 = commonVariable.rg0;
                        } else {
                          if (r1 !== -1) {
                            heapClassInst.heap32[g0] = r1;
                            heapClassInst.heap32[g0 + 1] = r0;
                            f0 = 0;
                            sputc(i7);
                            r1 = r6;
                            break repeat123;
                          } else {
                            r1 = (r6 + 1) | 0;
                            f0 = 0;
                            break repeat123;
                          }
                        }
                      }
                      r7 = (r6 + numDefine2) | 0;
                      r1 = (r4 + numDefineNeg48) | 0;
                      repeat135: do {
                        if (uint(r1) < uint(numDefine10)) {
                          r1 = (r6 + numDefine2) | 0;
                          r6 = 0;
                          while (true) {
                            r6 = (r6 * numDefine10) | 0;
                            heapClassInst.heap32[g0] = r0;
                            r6 = (r4 + r6) | 0;
                            sgetc(i7);
                            r4 = commonVariable.rg0;
                            r6 = (r6 + numDefineNeg48) | 0;
                            r1 = (r1 + 1) | 0;
                            r9 = (r4 + numDefineNeg48) | 0;
                            if (!(uint(r9) < uint(numDefine10))) {
                              break repeat135;
                            }
                          }
                        } else {
                          r6 = 0;
                          r1 = r7;
                        }
                      } while (false);
                      if (r7 === r1) {
                        label = numDefine172;
                        break repeat1;
                      } else {
                        if (!(r6 === 0)) {
                          label = numDefine130;
                          while (true) {
                            r6 = (r6 + -1) | 0;
                            f0 = f0 * f1;
                            if (!(r6 !== 0)) {
                              break repeat123;
                            }
                          }
                        }
                      }
                    } else {
                      r1 = r6;
                    }
                  } while (false);
                  if (r5 !== 0) {
                    f0 = -f0;
                  }
                  r5 = r8 & numDefine255;
                  if (r5 !== 0) {
                    continue repeat1;
                  } else {
                    r5 = sp + numDefineNeg4;
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = numDefine4;
                    myArgTest(i7);
                    r5 = commonVariable.rg0;
                    r6 = r10 & numDefine255;
                    if (r6 === 0) {
                      r5 = r5 >> numDefine2;
                      r5 = heapClassInst.heap32[r5];
                      r5 = r5 >> numDefine2;
                      f0 = f0;
                      heapClassInst.heapFloat[r5] = f0;
                    } else {
                      r5 = r5 >> numDefine2;
                      r5 = heapClassInst.heap32[r5];
                      llvmWriteDouble(r5, f0);
                    }
                    r2 = (r2 + 1) | 0;
                    continue repeat1;
                  }
                }
              default:
                break;
            }
            r3 = r4 << numDefine2;
            r14 = myCtype;
            r3 = (r3 + r14) | 0;
            r15 = heapClassInst.heapU8[r3 + numDefine4];
            r3 = (r6 + 1) | 0;
            r6 = r15 & numDefine8;
            repeat155: do {
              if (!(r6 === 0)) {
                while (true) {
                  heapClassInst.heap32[g0] = r0;
                  sgetc(i7);
                  r4 = commonVariable.rg0;
                  r6 = r4 << numDefine2;
                  r6 = (r6 + r14) | 0;
                  r1 = (r1 + 1) | 0;
                  r6 = heapClassInst.heapU8[r6 + numDefine4];
                  r6 = r6 & numDefine8;
                  if (!(r6 !== 0)) {
                    break repeat155;
                  }
                }
              }
            } while (false);
            if (r4 === numDefine45) {
              heapClassInst.heap32[g0] = r0;
              r1 = (r1 + 1) | 0;
              r6 = 1;
              sgetc(i7);
              r4 = commonVariable.rg0;
            } else {
              r6 = 0;
            }
            if (r4 === numDefine43) {
              heapClassInst.heap32[g0] = r0;
              r14 = (r1 + 1) | 0;
              sgetc(i7);
              r4 = commonVariable.rg0;
            } else {
              r14 = r1;
            }
            if (r4 !== -1) {
              r7 = r7 & numDefine255;
              repeat168: do {
                if (r7 === 0) {
                  if (r13 !== numDefine16) {
                    label = numDefine68;
                  } else {
                    if (r4 !== numDefine48) {
                      label = numDefine68;
                    } else {
                      label = numDefine72;
                    }
                  }
                  repeat172: do {
                    if (label === numDefine68) {
                      if (!(r13 !== 0)) {
                        r7 = numDefine48;

                        r7 = r4 !== r7 ? 1 : 0;
                        if (!(r7 !== 0)) {
                          r13 = numDefine8;
                          break repeat172;
                        }
                      }
                      r7 = numDefine10;
                      r13 = r13 !== 0 ? r13 : r7;
                      r1 = r14;
                      break repeat168;
                    }
                  } while (false);
                  heapClassInst.heap32[g0] = r0;
                  sgetc(i7);
                  r4 = commonVariable.rg0;
                  r7 = r4 | numDefine32;
                  if (r7 === numDefine120) {
                    heapClassInst.heap32[g0] = r0;
                    r1 = (r14 + numDefine2) | 0;
                    r13 = numDefine16;
                    sgetc(i7);
                    r4 = commonVariable.rg0;
                  } else {
                    r1 = (r14 + 1) | 0;
                  }
                } else {
                  r1 = r14;
                }
              } while (false);
              r7 = 0;
              r15 = r7;
              r16 = r7;
              repeat184: while (true) {
                if (r5 === 0) {
                  break repeat184;
                } else {
                  if (r4 !== -1) {
                    r17 = r4 & numDefine255;
                    r18 = r17 | numDefine32;
                    if (uint(r18) < uint(numDefine97)) {
                      r18 = numDefine58;
                      r19 = (r17 + numDefineNeg48) | 0;
                      r17 = uint(r17) < uint(r18) ? r19 : r20;
                    } else {
                      r17 = (r18 + numDefineNeg87) | 0;
                    }
                    if (uint(r17) >= uint(r13)) {
                      break repeat184;
                    } else {
                      heapClassInst.heap32[g0] = r15;
                      heapClassInst.heap32[g0 + 1] = r16;
                      heapClassInst.heap32[g0 + numDefine2] = r13;
                      heapClassInst.heap32[g0 + numDefine3] = r7;
                      muldi3(i7);
                      r4 = commonVariable.rg0;
                      r18 = commonVariable.rg1;

                      r15 = uint(r4) >= uint(r15) ? 1 : 0;
                      r19 = uint(r18) >= uint(r16) ? 1 : 0;
                      r15 = r18 === r16 ? r15 : r19;
                      if (r15 !== 0) {
                        r15 = (r17 + r4) | 0;
                        r16 = 1;
                        r17 = uint(r15) < uint(r17) ? r16 : r7;
                        r4 = uint(r15) < uint(r4) ? r16 : r17;
                        r16 = (r18 + r4) | 0;
                      } else {
                        r15 = -1;
                        r16 = r15;
                      }
                      heapClassInst.heap32[g0] = r0;
                      r1 = (r1 + 1) | 0;
                      r5 = (r5 + -1) | 0;
                      sgetc(i7);
                      r4 = commonVariable.rg0;
                    }
                  } else {
                    break repeat184;
                  }
                }
              }
              if (r14 === r1) {
                label = numDefine172;
                break repeat1;
              } else {
                r5 = r12 | numDefine32;
                if (!(uint(r5) > uint(numDefine111))) {
                  if (r16 > -1) {
                    r5 = 1;
                    r12 = (r7 - r16) | 0;
                    r5 = r15 !== 0 ? r5 : r7;
                    r7 = (r7 - r15) | 0;
                    r5 = (r12 - r5) | 0;
                    r15 = r6 !== 0 ? r7 : r15;
                    r16 = r6 !== 0 ? r5 : r16;
                  }
                }
                r5 = r8 & numDefine255;
                if (r5 !== 0) {
                  continue repeat1;
                } else {
                  r5 = r11 & numDefine255;
                  if (r5 === 0) {
                    r5 = r10 & numDefine255;
                    if (r5 === 0) {
                      r5 = sp + numDefineNeg4;
                      heapClassInst.heap32[g0] = r5;
                      heapClassInst.heap32[g0 + 1] = numDefine4;
                      myArgTest(i7);
                      r5 = commonVariable.rg0;
                      r7 = r9 & numDefine255;
                      if (r7 === 0) {
                        r5 = r5 >> numDefine2;
                        r5 = heapClassInst.heap32[r5];
                        r5 = r5 >> numDefine2;
                        heapClassInst.heap32[r5] = r15;
                      } else {
                        r5 = r5 >> numDefine2;
                        r5 = heapClassInst.heap32[r5];
                        heapClassInst.heap16[r5 >> 1] = r15;
                      }
                    } else {
                      r5 = sp + numDefineNeg4;
                      heapClassInst.heap32[g0] = r5;
                      heapClassInst.heap32[g0 + 1] = numDefine4;
                      myArgTest(i7);
                      r5 = commonVariable.rg0 >> numDefine2;
                      r5 = heapClassInst.heap32[r5];
                      r5 = r5 >> numDefine2;
                      heapClassInst.heap32[r5] = r15;
                    }
                  } else {
                    r5 = sp + numDefineNeg4;
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = numDefine4;
                    myArgTest(i7);
                    r5 = commonVariable.rg0 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    r5 = r5 >> numDefine2;
                    heapClassInst.heap32[r5] = r15;
                    heapClassInst.heap32[r5 + 1] = r16;
                  }

                  r5 = uint(r14) < uint(r1) ? 1 : 0;
                  r5 = r5 & 1;
                  r2 = (r5 + r2) | 0;
                  continue repeat1;
                }
              }
            } else {
              label = numDefine172;
              break repeat1;
            }
          } else {
            label = numDefine165;
          }
        }
      } else {
        if (r5 === 0) {
          label = numDefine6;
          break repeat1;
        } else {
          r7 = (r5 + numDefineNeg9) | 0;
          if (uint(r7) < uint(numDefine5)) {
            label = numDefine7;
          } else {
            label = numDefine165;
          }
        }
      }
      switch (label) {
        case numDefine7:
          r3 = (r3 + 1) | 0;
          repeat218: while (true) {
            r5 = heapClassInst.heapU8[r3];
            if (r5 === 0) {
              break repeat218;
            } else {
              r5 = r5 << numDefine24;
              r5 = r5 >> numDefine24;
              r5 = r5 << numDefine2;
              r6 = myCtype;
              r5 = (r5 + r6) | 0;
              r5 = heapClassInst.heapU8[r5 + numDefine4];
              r5 = r5 & numDefine8;
              if (r5 === 0) {
                break repeat218;
              } else {
                r3 = (r3 + 1) | 0;
              }
            }
          }
          r6 = r4 << numDefine2;
          r5 = myCtype;
          r6 = (r6 + r5) | 0;
          r6 = heapClassInst.heapU8[r6 + numDefine4];
          r6 = r6 & numDefine8;
          if (r6 === 0) {
            continue repeat1;
          } else {
            label = numDefine12;
            while (true) {
              heapClassInst.heap32[g0] = r0;
              sgetc(i7);
              r4 = commonVariable.rg0;
              r6 = r4 << numDefine2;
              r6 = (r6 + r5) | 0;
              r1 = (r1 + 1) | 0;
              r6 = heapClassInst.heapU8[r6 + numDefine4];
              r6 = r6 & numDefine8;
              if (r6 === 0) {
                continue repeat1;
              }
            }
          }
        case numDefine165:
          r3 = r4 & numDefine255;
          if (r3 !== r5) {
            label = numDefine168;
            break repeat1;
          } else {
            heapClassInst.heap32[g0] = r0;
            r1 = (r1 + 1) | 0;
            sgetc(i7);
            r4 = commonVariable.rg0;
            r3 = r6;
            continue repeat1;
          }
          break;
        default:
          break;
      }
    } else {
      label = numDefine168;
      break repeat1;
    }
  }
  repeat227: do {
    switch (label) {
      case numDefine168:
        if (!(r4 > -1)) {
          if (!(r2 !== 0)) {
            r2 = -1;
            break repeat227;
          }
        }
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r0;
        sputc(i7);
        break;
      case numDefine6:
        r2 = 0;
        break;
      default:
        break;
    }
  } while (false);
  commonVariable.rg0 = r2;
  return;
}

function fprintf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg8;
  r1 = r0 >> numDefine2;
  r2 = swriteIndex.fwriteIndex;
  heapClassInst.heap32[fp + numDefineNeg3] = sp;
  heapClassInst.heap32[r1 + 1] = r2;
  heapClassInst.heap32[fp + numDefineNeg2] = numDefine3;
  r1 = twoEStr3133;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = sp;
  vPrintf(i7);
  return;
}

function sprintf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = (sp + numDefine8) | 0;
  r1 = sp + numDefineNeg16;
  r2 = r1 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg7] = r0;
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r2 + 1] = 0;
  r4 = sp + numDefineNeg24;
  heapClassInst.heap32[fp + numDefineNeg4] = r3;
  r5 = r4 >> numDefine2;
  r6 = swriteIndex.swriteIndexNew;
  heapClassInst.heap32[r2 + numDefine2] = numDefineNeg2;
  heapClassInst.heap32[r5 + 1] = r6;
  heapClassInst.heap32[fp + numDefineNeg6] = r1;
  r1 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r0;
  vPrintf(i7);
  r0 = commonVariable.rg0;
  if (!(r3 === 0)) {
    if (!(r0 < 0)) {
      r1 = 0;
      heapClassInst.heap8[r3 + r0] = r1;
    }
  }
  commonVariable.rg0 = r0;
  return;
}

function zn12mandreelB64L11b64EncodeEPKhjPcjjPNS6B64RCE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = (r0 + numDefine2) | 0;
  r2 = heapClassInst.heap32[fp + numDefine4];
  r1 = Math.floor(uint(r1) / uint(numDefine3));
  r3 = heapClassInst.heap32[fp + numDefine2];
  r1 = r1 << numDefine2;
  r4 = r2 >> numDefine2;
  heapClassInst.heap32[r4] = 0;
  repeat1: do {
    if (!(r3 === 0)) {
      r5 = heapClassInst.heap32[fp + numDefine3];
      if (uint(r1) <= uint(r5)) {
        r4 = heapClassInst.heap32[fp];
        if (uint(r0) > uint(numDefine2)) {
          r5 = (r3 + r5) | 0;
          r6 = 0;
          r12 = zn12mandreelB64L9b64CharsE;
          repeat7: while (true) {
            r7 = heapClassInst.heapU8[r4];
            r8 = heapClassInst.heapU8[r4 + 1];
            r9 = r7 << numDefine4;
            r10 = heapClassInst.heapU8[r4 + numDefine2];
            r11 = r8 << numDefine2;
            r9 = r9 & numDefine48;
            r8 = r8 >>> numDefine4;
            r7 = r7 >>> numDefine2;
            r8 = r9 | r8;
            r9 = r11 & numDefine60;
            r11 = r10 >>> numDefine6;
            r7 = heapClassInst.heapU8[r12 + r7];
            r9 = r9 | r11;
            r8 = heapClassInst.heapU8[r12 + r8];
            heapClassInst.heap8[r3] = r7;
            r7 = r10 & numDefine63;
            r9 = heapClassInst.heapU8[r12 + r9];
            heapClassInst.heap8[r3 + 1] = r8;
            r8 = (r3 + numDefine4) | 0;
            r6 = (r6 + numDefine4) | 0;
            r7 = heapClassInst.heapU8[r12 + r7];
            heapClassInst.heap8[r3 + numDefine2] = r9;
            heapClassInst.heap8[r3 + numDefine3] = r7;
            if (r8 === r5) {
              label = numDefine7;
            } else {
              if (r6 === 0) {
                r7 = numDefine13;
                r8 = (r3 + numDefine6) | 0;
                r6 = 0;
                r9 = numDefine10;
                heapClassInst.heap8[r3 + numDefine4] = r7;
                heapClassInst.heap8[r3 + numDefine5] = r9;
                r3 = r8;
                label = numDefine9;
              } else {
                label = numDefine7;
              }
            }
            if (label === numDefine7) {
              r3 = r8;
            }
            r0 = (r0 + numDefineNeg3) | 0;
            r4 = (r4 + numDefine3) | 0;
            if (!(uint(r0) > uint(numDefine2))) {
              break repeat7;
            }
          }
        }
        if (!(r0 === 0)) {
          r5 = 0;
          repeat17: while (true) {
            r6 = sp + numDefineNeg3;
            r7 = (r4 - r5) | 0;
            r8 = (r5 + -1) | 0;
            r5 = (r6 - r5) | 0;
            r7 = heapClassInst.heapU8[r7];
            heapClassInst.heap8[r5] = r7;
            r7 = (r0 + r8) | 0;
            r5 = r8;
            if (!(r7 !== 0)) {
              break repeat17;
            }
          }
          if (r0 !== numDefine3) {
            r4 = numDefine3;
            r5 = (r4 - r0) | 0;
            r8 = 0;
            repeat22: while (true) {
              r7 = (r5 + -1) | 0;
              r5 = (r6 - r5) | 0;
              heapClassInst.heap8[r5 + numDefine3] = r8;
              r5 = r7;
              if (!(r7 !== 0)) {
                break repeat22;
              }
            }
            heapClassInst.heap32[g0] = r6;
            heapClassInst.heap32[g0 + 1] = numDefine3;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            heapClassInst.heap32[g0 + numDefine3] = numDefine12;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            r0 = (r4 - r0) | 0;
            zn12mandreelB64L11b64EncodeEPKhjPcjjPNS6B64RCE(i7);
            r4 = numDefine61;
            repeat25: while (true) {
              r2 = (r0 + -1) | 0;
              r0 = (r3 - r0) | 0;
              heapClassInst.heap8[r0 + numDefine4] = r4;
              r0 = r2;
              if (r2 !== 0) {
                continue repeat25;
              } else {
                break repeat1;
              }
            }
          } else {
            heapClassInst.heap32[g0] = r6;
            heapClassInst.heap32[g0 + 1] = numDefine3;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            heapClassInst.heap32[g0 + numDefine3] = numDefine12;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            zn12mandreelB64L11b64EncodeEPKhjPcjjPNS6B64RCE(i7);
            commonVariable.rg0 = r1;
            return;
          }
        }
      } else {
        heapClassInst.heap32[r4] = 1;
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
      }
    }
  } while (false);
  commonVariable.rg0 = r1;
  return;
}

function zn12mandreelB6410b64DecodeEPKcjPvj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 & numDefine3;
  r2 = 0;

  r1 = r1 !== r2 ? 1 : 0;
  r1 = r1 & 1;
  r3 = r0 >>> numDefine2;
  r1 = (r1 + r3) | 0;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r1 = (r1 * numDefine3) | 0;
  if (r3 !== 0) {
    r4 = heapClassInst.heap32[fp + numDefine3];
    if (uint(r1) <= uint(r4)) {
      r1 = heapClassInst.heap32[fp];
      r4 = r3;
      r5 = r2;
      repeat5: while (true) {
        if (r0 !== 0) {
          r6 = heapClassInst.heapU8[r1];
          if (r6 !== numDefine61) {
            r7 = zn12mandreelB64L11b64IndexesE;
            r6 = heapClassInst.heapU8[r7 + r6];
            if (r6 !== numDefine255) {
              r5 = 0;
              r7 = sp + numDefineNeg4;
              heapClassInst.heap8[r7 + r2] = r6;
              label = numDefine8;
            } else {
              label = numDefine15;
            }
          } else {
            r5 = (r5 + 1) | 0;
            r6 = sp + numDefineNeg4;
            r7 = 0;
            heapClassInst.heap8[r6 + r2] = r7;
            label = numDefine8;
          }
          if (label === numDefine8) {
            r2 = (r2 + 1) | 0;
            if (r2 === numDefine4) {
              r2 = heapClassInst.heapU8[sp + numDefineNeg3];
              r6 = heapClassInst.heapU8[sp + numDefineNeg4];
              r2 = r2 >>> numDefine4;
              r2 = r2 & numDefine3;
              r6 = r6 << numDefine2;
              r2 = r2 | r6;
              heapClassInst.heap8[r4] = r2;
              if (r5 !== numDefine2) {
                r2 = heapClassInst.heapU8[sp + numDefineNeg2];
                r6 = heapClassInst.heapU8[sp + numDefineNeg3];
                r2 = r2 >>> numDefine2;
                r2 = r2 & numDefine15;
                r6 = r6 << numDefine4;
                r2 = r2 | r6;
                heapClassInst.heap8[r4 + 1] = r2;
                if (r5 !== 1) {
                  r2 = heapClassInst.heapU8[sp + numDefineNeg2];
                  r7 = heapClassInst.heapU8[sp + -1];
                  r2 = r2 << numDefine6;
                  r6 = (r4 + numDefine3) | 0;
                  r2 = (r2 + r7) | 0;
                  heapClassInst.heap8[r4 + numDefine2] = r2;
                  if (r5 === 0) {
                    r2 = 0;
                    r4 = r6;
                    r5 = r2;
                  } else {
                    label = numDefine18;
                    break repeat5;
                  }
                } else {
                  label = numDefine12;
                  break repeat5;
                }
              } else {
                label = numDefine10;
                break repeat5;
              }
            }
          }
          r0 = (r0 + -1) | 0;
          r1 = (r1 + 1) | 0;
        } else {
          label = numDefine17;
          break repeat5;
        }
      }
      switch (label) {
        case numDefine17:
          r6 = r4;
          break;
        case numDefine12:
          r6 = (r4 + numDefine2) | 0;
          break;
        case numDefine10:
          r6 = (r4 + 1) | 0;
          break;
        default:
          break;
      }
      r1 = (r6 - r3) | 0;
    } else {
      r1 = 0;
    }
  }
  commonVariable.rg0 = r1;
  return;
}

function mandreelInternalInit(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg2456;
  let g0 = i7 >> numDefine2;
  r0 = swriteIndex.mandreelInternalSetResolutionIndex;
  r1 = zz24MandreelInternalInitE54s723478567MandreelMandreelInternalSetResolution;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  iMandreelRegisterExternalCallback(i7);
  r0 = swriteIndex.iMandreelTextureAsyncIsCompressedIndex;
  r1 = zz24MandreelInternalInitE56s723478567MandreelIMandreelTextureAsyncIsCompressed;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  iMandreelRegisterExternalCallback(i7);
  r0 = swriteIndex.iMandreelTextureAsyncGetPackOffsetIndex;
  r1 = zz24MandreelInternalInitE57s723478567MandreelIMandreelTextureAsyncGetPackOffset;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  iMandreelRegisterExternalCallback(i7);
  r0 = swriteIndex.resizeIndex;
  r1 = zz24MandreelInternalInitE29s723478567MandreelResize;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  iMandreelRegisterExternalCallback(i7);
  r0 = swriteIndex.imandreelRestoreGlcontextIndex;
  r1 = zz24MandreelInternalInitE48s723478567MandreelImandreelRestoreGlcontext;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  iMandreelRegisterExternalCallback(i7);
  r0 = swriteIndex.imandreelViewportResizeIndex;
  r1 = zz24MandreelInternalInitE46s723478567MandreelImandreelViewportResize;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  r0 = gMsgcallback;
  r0 = r0 >> numDefine2;
  r1 = swriteIndex.z31MandreelDefaultDebugMsgCallbackiPKcIndex;
  iMandreelRegisterExternalCallback(i7);
  r2 = zl7gBInit2EB;
  heapClassInst.heap32[r0] = r1;
  r0 = heapClassInst.heapU8[r2];
  if (r0 !== 1) {
    r0 = 1;
    heapClassInst.heap8[r2] = r0;
    r1 = 0;
    mandreelAudioIsLogEnabled(i7);

    r2 = commonVariable.rg0 !== r1 ? 1 : 0;
    r3 = zl6gBLog;
    r2 = r2 & 1;
    heapClassInst.heap8[r3] = r2;
    mandreelAudioUseMusicFunctionsNew(i7);
    r2 = heapClassInst.heapU8[r3];
    if (r2 !== 0) {
      r2 = twoEStr35256;
      heapClassInst.heap32[g0] = r2;
      printf(i7);
    } else {
      r1 = 0;
    }
    repeat6: while (true) {
      r2 = (r1 * numDefine73) | 0;
      r3 = zl11gAChannels;
      r2 = r2 << numDefine2;
      r2 = (r3 + r2) | 0;
      r4 = (r1 * numDefine292) | 0;
      r2 = r2 >> numDefine2;
      r5 = zl15gAFreeChannels;
      r6 = r1 << numDefine2;
      r5 = (r5 + r6) | 0;
      r3 = (r3 + r4) | 0;
      heapClassInst.heap32[r2 + numDefine69] = r1;
      r2 = (r1 + 1) | 0;
      r4 = r5 >> numDefine2;
      heapClassInst.heap8[r3 + numDefine269] = r0;
      heapClassInst.heap32[r4] = r1;
      r1 = r2;
      if (!(r2 !== numDefine32)) {
        break repeat6;
      }
    }
    r1 = zl15gIFreeChannels;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r1] = numDefine32;
    mandreelAudioInit(i7);
    r1 = twoEStr22243;
    heapClassInst.heap32[g0] = r1;
    printf(i7);
    heapClassInst.heap32[g0] = 0;
    z30MandreelFopenEnableCheckfatb(i7);
    r1 = twoEStr779;
    r2 = twoEStr1648;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r2;
    fopen(i7);
    r3 = commonVariable.rg0;
    heapClassInst.heap32[g0] = 1;
    z30MandreelFopenEnableCheckfatb(i7);
    if (r3 === 0) {
      r4 = twoEStr24245;
      r5 = 0;
      heapClassInst.heap32[g0] = r4;
      printfError(i7);
      r4 = r5;
    } else {
      if (uint(r3) < uint(numDefine10)) {
        r4 = zl13sFileStdout;
        r5 = r4 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine7];
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = numDefine2;
        functionTable[r5 >> numDefine2](i7);
      } else {
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine7];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = numDefine2;
        functionTable[r4 >> numDefine2](i7);
        r4 = r3;
      }
      r5 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + numDefine5];
      heapClassInst.heap32[g0] = r4;
      functionTable[r5 >> numDefine2](i7);
      r4 = commonVariable.rg0;
      if (uint(r3) > uint(numDefine9)) {
        r5 = r3;
      } else {
        r5 = zl13sFileStdout;
      }
      r6 = r5 >> numDefine2;
      r6 = heapClassInst.heap32[r6];
      r6 = r6 >> numDefine2;
      r6 = heapClassInst.heap32[r6 + numDefine7];
      heapClassInst.heap32[g0] = r5;
      heapClassInst.heap32[g0 + 1] = 0;
      heapClassInst.heap32[g0 + numDefine2] = 0;
      functionTable[r6 >> numDefine2](i7);
      r5 = (r4 + 1) | 0;
      heapClassInst.heap32[g0] = r5;
      mallocNew(i7);
      r5 = commonVariable.rg0;
      if (uint(r3) < uint(numDefine10)) {
        r6 = zl13sFileStdout;
        r7 = r6 >> numDefine2;
        r7 = heapClassInst.heap32[r7];
        r7 = r7 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + 1];
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        r8 = 0;
        functionTable[r7 >> numDefine2](i7);
        heapClassInst.heap8[r5 + r4] = r8;
      } else {
        r6 = r3 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + 1];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        r7 = 0;
        functionTable[r6 >> numDefine2](i7);
        heapClassInst.heap8[r5 + r4] = r7;
        r6 = r3;
      }
      r7 = r6 >> numDefine2;
      r7 = heapClassInst.heap32[r7];
      r7 = r7 >> numDefine2;
      r7 = heapClassInst.heap32[r7 + numDefine4];
      heapClassInst.heap32[g0] = r6;
      functionTable[r7 >> numDefine2](i7);
      if (uint(r3) > uint(numDefine9)) {
        heapClassInst.heap32[g0] = r6;
        zdlPv(i7);
      }
    }
    r3 = sp + numDefineNeg128;
    heapClassInst.heap32[g0] = r3;
    mandreelAudioGetAudioDriverName(i7);
    r6 = twoEStr4225;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r6;
    strcmp(i7);
    r3 = commonVariable.rg0;
    if (!(r5 === 0)) {
      repeat28: do {
        if (!(r4 < 1)) {
          r6 = sp + numDefineNeg1408;
          r7 = (r6 + 1) | 0;
          r8 = (r5 + 1) | 0;
          r9 = 0;
          while (true) {
            r10 = (r5 + r9) | 0;
            r11 = heapClassInst.heapU8[r5 + r9];
            if (!(r11 === numDefine13)) {
              if (r9 < r4) {
                r11 = r9;
                repeat35: while (true) {
                  r9 = (r11 + 1) | 0;
                  r11 = heapClassInst.heapU8[r8 + r11];
                  if (r11 === numDefine13) {
                    break repeat35;
                  } else {
                    r11 = r9;
                    if (!(r9 < r4)) {
                      break repeat35;
                    }
                  }
                }
              }
            }
            r11 = zl10strtokPos;
            r12 = 0;
            r11 = r11 >> numDefine2;
            heapClassInst.heap8[r5 + r9] = r12;
            r13 = heapClassInst.heap32[r11];
            r9 = (r9 + numDefine2) | 0;
            r10 = r10 === 0 ? r13 : r10;
            repeat39: while (true) {
              r13 = heapClassInst.heapU8[r10];
              if (r13 === 0) {
                label = numDefine44;
                break repeat39;
              } else {
                r14 = r12;
                repeat42: while (true) {
                  if (r14 === -1) {
                    label = numDefine34;
                    break repeat39;
                  } else {
                    r15 = twoEStr4133;
                    r15 = (r15 - r14) | 0;
                    r16 = r13 & numDefine255;
                    r15 = heapClassInst.heapU8[r15];
                    if (r16 !== r15) {
                      r14 = (r14 + -1) | 0;
                    } else {
                      break repeat42;
                    }
                  }
                }
                r10 = (r10 + 1) | 0;
              }
            }
            repeat47: do {
              if (label === numDefine34) {
                if (r13 === 0) {
                  label = numDefine44;
                } else {
                  r12 = r10;
                  repeat50: while (true) {
                    r13 = heapClassInst.heapU8[r12];
                    if (r13 === 0) {
                      break repeat50;
                    } else {
                      r14 = r0;
                      repeat53: while (true) {
                        if (r14 !== 0) {
                          r15 = twoEStr4133;
                          r15 = (r15 - r14) | 0;
                          r16 = r13 & numDefine255;
                          r15 = heapClassInst.heapU8[r15 + 1];
                          if (r16 === r15) {
                            break repeat50;
                          } else {
                            r14 = (r14 + -1) | 0;
                          }
                        } else {
                          break repeat53;
                        }
                      }
                      r12 = (r12 + 1) | 0;
                    }
                  }
                  r13 = heapClassInst.heapU8[r12];
                  if (r13 !== 0) {
                    r13 = (r12 + 1) | 0;
                    r14 = 0;
                    heapClassInst.heap8[r12] = r14;
                    r12 = r13;
                  }
                  heapClassInst.heap32[r11] = r12;
                  r13 = twoEStr26247;
                  heapClassInst.heap32[g0] = r13;
                  heapClassInst.heap32[g0 + 1] = r10;
                  strcmp(i7);
                  r13 = commonVariable.rg0;
                  if (r13 !== 0) {
                    r13 = twoEStr29250;
                    heapClassInst.heap32[g0] = r13;
                    heapClassInst.heap32[g0 + 1] = r10;
                    strcmp(i7);
                    r13 = commonVariable.rg0;
                    if (r13 !== 0) {
                      if (r3 !== 0) {
                        label = numDefine66;
                        break repeat47;
                      } else {
                        r13 = twoEStr32253;
                        heapClassInst.heap32[g0] = r13;
                        heapClassInst.heap32[g0 + 1] = r10;
                        strcmp(i7);
                        r13 = commonVariable.rg0;
                        if (r13 !== 0) {
                          r13 = twoEStr33254;
                          heapClassInst.heap32[g0] = r13;
                          heapClassInst.heap32[g0 + 1] = r10;
                          strcmp(i7);
                          r10 = commonVariable.rg0;
                          if (r10 !== 0) {
                            label = numDefine66;
                            break repeat47;
                          } else {
                            label = numDefine173;
                            repeat69: while (true) {
                              r10 = heapClassInst.heapU8[r12];
                              if (r10 === 0) {
                                label = numDefine175;
                                break repeat69;
                              } else {
                                r13 = 0;
                                repeat72: while (true) {
                                  if (r13 === -1) {
                                    label = numDefine176;
                                    break repeat69;
                                  } else {
                                    r14 = twoEStr4133;
                                    r14 = (r14 - r13) | 0;
                                    r15 = r10 & numDefine255;
                                    r14 = heapClassInst.heapU8[r14];
                                    if (r15 !== r14) {
                                      r13 = (r13 + -1) | 0;
                                    } else {
                                      break repeat72;
                                    }
                                  }
                                }
                                r12 = (r12 + 1) | 0;
                              }
                            }
                            if (label === numDefine176) {
                              if (r10 === 0) {
                                label = numDefine175;
                              } else {
                                r13 = r12;
                                repeat80: while (true) {
                                  r10 = heapClassInst.heapU8[r13];
                                  if (r10 === 0) {
                                    break repeat80;
                                  } else {
                                    r14 = 1;
                                    repeat83: while (true) {
                                      if (r14 !== 0) {
                                        r15 = twoEStr4133;
                                        r15 = (r15 - r14) | 0;
                                        r16 = r10 & numDefine255;
                                        r15 = heapClassInst.heapU8[r15 + 1];
                                        if (r16 === r15) {
                                          break repeat80;
                                        } else {
                                          r14 = (r14 + -1) | 0;
                                        }
                                      } else {
                                        break repeat83;
                                      }
                                    }
                                    r13 = (r13 + 1) | 0;
                                  }
                                }
                                r10 = heapClassInst.heapU8[r13];
                                if (r10 !== 0) {
                                  r14 = (r13 + 1) | 0;
                                  r10 = 0;
                                  heapClassInst.heap8[r13] = r10;
                                  r10 = r12;
                                  r12 = r14;
                                  label = numDefine187;
                                } else {
                                  r10 = r12;
                                  r12 = r13;
                                  label = numDefine187;
                                }
                              }
                            }
                            if (label === numDefine175) {
                              r10 = 0;
                            }
                            heapClassInst.heap32[r11] = r12;
                            r11 = sp + numDefineNeg384;
                            heapClassInst.heap32[g0] = r11;
                            heapClassInst.heap32[g0 + 1] = r10;
                            strcpy(i7);
                            label = numDefine66;
                            break repeat47;
                          }
                        } else {
                          repeat95: while (true) {
                            r10 = heapClassInst.heapU8[r12];
                            if (r10 === 0) {
                              label = numDefine155;
                              break repeat95;
                            } else {
                              r13 = 0;
                              repeat98: while (true) {
                                if (r13 === -1) {
                                  label = numDefine156;
                                  break repeat95;
                                } else {
                                  r14 = twoEStr4133;
                                  r14 = (r14 - r13) | 0;
                                  r15 = r10 & numDefine255;
                                  r14 = heapClassInst.heapU8[r14];
                                  if (r15 !== r14) {
                                    r13 = (r13 + -1) | 0;
                                  } else {
                                    break repeat98;
                                  }
                                }
                              }
                              r12 = (r12 + 1) | 0;
                            }
                          }
                          if (label === numDefine156) {
                            if (r10 === 0) {
                              label = numDefine155;
                            } else {
                              r13 = r12;
                              repeat106: while (true) {
                                r10 = heapClassInst.heapU8[r13];
                                if (r10 === 0) {
                                  break repeat106;
                                } else {
                                  r14 = 1;
                                  repeat109: while (true) {
                                    if (r14 !== 0) {
                                      r15 = twoEStr4133;
                                      r15 = (r15 - r14) | 0;
                                      r16 = r10 & numDefine255;
                                      r15 = heapClassInst.heapU8[r15 + 1];
                                      if (r16 === r15) {
                                        break repeat106;
                                      } else {
                                        r14 = (r14 + -1) | 0;
                                      }
                                    } else {
                                      break repeat109;
                                    }
                                  }
                                  r13 = (r13 + 1) | 0;
                                }
                              }
                              r10 = heapClassInst.heapU8[r13];
                              if (r10 !== 0) {
                                r14 = (r13 + 1) | 0;
                                r10 = 0;
                                heapClassInst.heap8[r13] = r10;
                                r10 = r12;
                                r12 = r14;
                                label = numDefine167;
                              } else {
                                r10 = r12;
                                r12 = r13;
                                label = numDefine167;
                              }
                            }
                          }
                          if (label === numDefine155) {
                            r10 = 0;
                          }
                          heapClassInst.heap32[r11] = r12;
                          r11 = sp + numDefineNeg2432;
                          r12 = twoEStr12233;
                          r13 = sp + numDefineNeg384;
                          heapClassInst.heap32[g0] = r11;
                          heapClassInst.heap32[g0 + 1] = r12;
                          heapClassInst.heap32[g0 + numDefine2] = r13;
                          heapClassInst.heap32[g0 + numDefine3] = r10;
                          sprintf(i7);
                          heapClassInst.heap32[g0] = r11;
                          mandreelAddValidFopenfile(i7);
                          label = numDefine66;
                          break repeat47;
                        }
                      }
                    } else {
                      r10 = (r12 + 1) | 0;
                      r13 = 0;
                      r14 = r12;
                      repeat122: while (true) {
                        r15 = heapClassInst.heapU8[r12 + r13];
                        if (r15 === 0) {
                          label = numDefine85;
                          break repeat122;
                        } else {
                          r16 = 0;
                          repeat125: while (true) {
                            if (r16 === -1) {
                              label = numDefine75;
                              break repeat122;
                            } else {
                              r17 = twoEStr4133;
                              r17 = (r17 - r16) | 0;
                              r18 = r15 & numDefine255;
                              r17 = heapClassInst.heapU8[r17];
                              if (r18 !== r17) {
                                r16 = (r16 + -1) | 0;
                              } else {
                                break repeat125;
                              }
                            }
                          }
                          r13 = (r13 + 1) | 0;
                          r14 = (r14 + 1) | 0;
                          r10 = (r10 + 1) | 0;
                        }
                      }
                      repeat130: do {
                        if (label === numDefine75) {
                          if (r15 === 0) {
                            label = numDefine85;
                          } else {
                            r15 = (r12 + r13) | 0;
                            repeat133: while (true) {
                              r16 = heapClassInst.heapU8[r14];
                              if (r16 === 0) {
                                break repeat133;
                              } else {
                                r17 = 1;
                                repeat136: while (true) {
                                  if (r17 !== 0) {
                                    r18 = twoEStr4133;
                                    r18 = (r18 - r17) | 0;
                                    r19 = r16 & numDefine255;
                                    r18 = heapClassInst.heapU8[r18 + 1];
                                    if (r19 === r18) {
                                      break repeat133;
                                    } else {
                                      r17 = (r17 + -1) | 0;
                                    }
                                  } else {
                                    break repeat136;
                                  }
                                }
                                r14 = (r14 + 1) | 0;
                              }
                            }
                            r16 = heapClassInst.heapU8[r14];
                            if (r16 !== 0) {
                              r16 = (r14 + 1) | 0;
                              r17 = 0;
                              heapClassInst.heap8[r14] = r17;
                              r14 = r16;
                            }
                            r17 = 0;

                            r16 = r15 === r17 ? 1 : 0;
                            heapClassInst.heap32[r11] = r14;
                            repeat145: while (true) {
                              r18 = heapClassInst.heapU8[r14];
                              if (r18 === 0) {
                                label = numDefine103;
                                break repeat145;
                              } else {
                                r19 = r17;
                                repeat148: while (true) {
                                  if (r19 === -1) {
                                    label = numDefine93;
                                    break repeat145;
                                  } else {
                                    r20 = twoEStr4133;
                                    r20 = (r20 - r19) | 0;
                                    r21 = r18 & numDefine255;
                                    r20 = heapClassInst.heapU8[r20];
                                    if (r21 !== r20) {
                                      r19 = (r19 + -1) | 0;
                                    } else {
                                      break repeat148;
                                    }
                                  }
                                }
                                r14 = (r14 + 1) | 0;
                              }
                            }
                            if (label === numDefine93) {
                              if (!(r18 === 0)) {
                                r17 = r14;
                                repeat156: while (true) {
                                  r18 = heapClassInst.heapU8[r17];
                                  if (r18 === 0) {
                                    break repeat156;
                                  } else {
                                    r19 = 1;
                                    repeat159: while (true) {
                                      if (r19 !== 0) {
                                        r20 = twoEStr4133;
                                        r20 = (r20 - r19) | 0;
                                        r21 = r18 & numDefine255;
                                        r20 = heapClassInst.heapU8[r20 + 1];
                                        if (r21 === r20) {
                                          break repeat156;
                                        } else {
                                          r19 = (r19 + -1) | 0;
                                        }
                                      } else {
                                        break repeat159;
                                      }
                                    }
                                    r17 = (r17 + 1) | 0;
                                  }
                                }
                                r18 = heapClassInst.heapU8[r17];
                                if (r18 !== 0) {
                                  r18 = (r17 + 1) | 0;
                                  r19 = 0;
                                  heapClassInst.heap8[r17] = r19;
                                  r17 = r18;
                                }
                                heapClassInst.heap32[r11] = r17;
                                repeat168: while (true) {
                                  r18 = heapClassInst.heapU8[r17];
                                  if (r18 === 0) {
                                    label = numDefine121;
                                    break repeat168;
                                  } else {
                                    r19 = 0;
                                    repeat171: while (true) {
                                      if (r19 === -1) {
                                        label = numDefine111;
                                        break repeat168;
                                      } else {
                                        r20 = twoEStr4133;
                                        r20 = (r20 - r19) | 0;
                                        r21 = r18 & numDefine255;
                                        r20 = heapClassInst.heapU8[r20];
                                        if (r21 !== r20) {
                                          r19 = (r19 + -1) | 0;
                                        } else {
                                          break repeat171;
                                        }
                                      }
                                    }
                                    r17 = (r17 + 1) | 0;
                                  }
                                }
                                if (label === numDefine111) {
                                  if (!(r18 === 0)) {
                                    r15 = r17;
                                    repeat179: while (true) {
                                      r16 = heapClassInst.heapU8[r15];
                                      if (r16 === 0) {
                                        break repeat179;
                                      } else {
                                        r18 = 1;
                                        repeat182: while (true) {
                                          if (r18 !== 0) {
                                            r19 = twoEStr4133;
                                            r19 = (r19 - r18) | 0;
                                            r20 = r16 & numDefine255;
                                            r19 = heapClassInst.heapU8[r19 + 1];
                                            if (r20 === r19) {
                                              break repeat179;
                                            } else {
                                              r18 = (r18 + -1) | 0;
                                            }
                                          } else {
                                            break repeat182;
                                          }
                                        }
                                        r15 = (r15 + 1) | 0;
                                      }
                                    }
                                    r16 = heapClassInst.heapU8[r15];
                                    if (r16 !== 0) {
                                      r16 = (r15 + 1) | 0;
                                      r18 = 0;
                                      heapClassInst.heap8[r15] = r18;
                                      r15 = r16;
                                    }
                                    heapClassInst.heap32[r11] = r15;
                                    heapClassInst.heap32[g0] = numDefine264;
                                    znwj(i7);
                                    r11 = commonVariable.rg0;
                                    heapClassInst.heap32[g0] = r17;
                                    heapClassInst.heap32[g0 + 1] = 0;
                                    r15 = 0;
                                    r16 = -1;
                                    r17 = r11 >> numDefine2;
                                    strtol(i7);
                                    heapClassInst.heap32[r17 + numDefine64] = commonVariable.rg0;
                                    repeat191: while (true) {
                                      r17 = r15;
                                      r18 = heapClassInst.heapU8[r10 + r17];
                                      if (r18 !== numDefine46) {
                                        if (r18 === 0) {
                                          break repeat191;
                                        } else {
                                          if (!(r18 === numDefine47)) {
                                            r15 = (r17 + 1) | 0;
                                            if (r18 !== numDefine92) {
                                              continue repeat191;
                                            }
                                          }
                                          r16 = -1;
                                        }
                                      } else {
                                        r16 = r17;
                                      }
                                      r15 = (r17 + 1) | 0;
                                    }
                                    if (r16 === -1) {
                                      r10 = (r12 + r13) | 0;
                                      r12 = twoEStr12233;
                                      r10 = (r10 + 1) | 0;
                                      r15 = twoEStr2131;
                                      heapClassInst.heap32[g0] = r6;
                                      heapClassInst.heap32[g0 + 1] = r12;
                                      heapClassInst.heap32[g0 + numDefine2] = r10;
                                      heapClassInst.heap32[g0 + numDefine3] = r15;
                                      sprintf(i7);
                                    } else {
                                      repeat205: do {
                                        if (r16 > 0) {
                                          r10 = (r12 + 1) | 0;
                                          r12 = 0;
                                          while (true) {
                                            r15 = (r12 + r10) | 0;
                                            r17 = (r12 + 1) | 0;
                                            r15 = heapClassInst.heapU8[r15 + r13];
                                            heapClassInst.heap8[r6 + r12] = r15;
                                            r12 = r17;
                                            if (!(r16 !== r17)) {
                                              break repeat205;
                                            }
                                          }
                                        } else {
                                          r16 = 0;
                                        }
                                      } while (false);
                                      r10 = (r6 + r16) | 0;
                                      r12 = twoEStr2131;
                                      heapClassInst.heap32[g0] = r10;
                                      heapClassInst.heap32[g0 + 1] = r12;
                                      strcpy(i7);
                                    }
                                    r10 = heapClassInst.heapU8[sp + numDefineNeg1408];
                                    repeat212: do {
                                      if (r10 === 0) {
                                        r15 = r11;
                                      } else {
                                        r12 = r7;
                                        r15 = r11;
                                        while (true) {
                                          r16 = r10 & numDefine255;
                                          if (r16 !== numDefine92) {
                                            r16 = r10 << numDefine24;
                                            r16 = r16 >> numDefine24;
                                            r16 = (r16 + numDefineNeg65) | 0;
                                            r13 = numDefine26;
                                            r17 = (r10 + numDefine32) | 0;
                                            r10 = uint(r16) < uint(r13) ? r17 : r10;
                                          } else {
                                            r10 = numDefine47;
                                          }
                                          heapClassInst.heap8[r15] = r10;
                                          r10 = heapClassInst.heapU8[r12];
                                          r15 = (r15 + 1) | 0;
                                          r12 = (r12 + 1) | 0;
                                          if (!(r10 !== 0)) {
                                            break repeat212;
                                          }
                                        }
                                      }
                                    } while (false);
                                    r10 = zl21gPFirstSoundDuration;
                                    r12 = 0;
                                    r10 = r10 >> numDefine2;
                                    heapClassInst.heap8[r15] = r12;
                                    r12 = r11 >> numDefine2;
                                    r15 = heapClassInst.heap32[r10];
                                    heapClassInst.heap32[r12 + numDefine65] = r15;
                                    heapClassInst.heap32[r10] = r11;
                                    r10 = heapClassInst.heapU8[r14];
                                    if (r10 === numDefine48) {
                                      label = numDefine66;
                                      break repeat47;
                                    } else {
                                      heapClassInst.heap32[g0] = r11;
                                      heapClassInst.heap32[g0 + 1] = 0;
                                      mandreelAudioCreateBuffer(i7);
                                      label = numDefine66;
                                      break repeat47;
                                    }
                                  }
                                }
                                heapClassInst.heap32[r11] = r17;
                                label = numDefine146;
                                break repeat130;
                              }
                            }
                            heapClassInst.heap32[r11] = r14;
                            label = numDefine146;
                          }
                        }
                      } while (false);
                      if (label === numDefine85) {
                        r16 = 1;
                        r15 = 0;
                        r10 = (r12 + r13) | 0;
                        heapClassInst.heap32[r11] = r10;
                      }
                      r10 = twoEStr30251;
                      r11 = twoEStr31252;
                      r10 = r16 !== 0 ? r10 : r15;
                      heapClassInst.heap32[g0] = r11;
                      heapClassInst.heap32[g0 + 1] = r10;
                      printfWarning(i7);
                      label = numDefine66;
                      break repeat47;
                    }
                  } else {
                    repeat228: while (true) {
                      r10 = heapClassInst.heapU8[r12];
                      if (r10 === 0) {
                        label = numDefine52;
                        break repeat228;
                      } else {
                        r13 = 0;
                        repeat231: while (true) {
                          if (r13 === -1) {
                            label = numDefine53;
                            break repeat228;
                          } else {
                            r14 = twoEStr4133;
                            r14 = (r14 - r13) | 0;
                            r15 = r10 & numDefine255;
                            r14 = heapClassInst.heapU8[r14];
                            if (r15 !== r14) {
                              r13 = (r13 + -1) | 0;
                            } else {
                              break repeat231;
                            }
                          }
                        }
                        r12 = (r12 + 1) | 0;
                      }
                    }
                    if (label === numDefine53) {
                      if (r10 === 0) {
                        label = numDefine52;
                      } else {
                        r13 = r12;
                        repeat239: while (true) {
                          r10 = heapClassInst.heapU8[r13];
                          if (r10 === 0) {
                            break repeat239;
                          } else {
                            r14 = 1;
                            repeat242: while (true) {
                              if (r14 !== 0) {
                                r15 = twoEStr4133;
                                r15 = (r15 - r14) | 0;
                                r16 = r10 & numDefine255;
                                r15 = heapClassInst.heapU8[r15 + 1];
                                if (r16 === r15) {
                                  break repeat239;
                                } else {
                                  r14 = (r14 + -1) | 0;
                                }
                              } else {
                                break repeat242;
                              }
                            }
                            r13 = (r13 + 1) | 0;
                          }
                        }
                        r10 = heapClassInst.heapU8[r13];
                        if (r10 !== 0) {
                          r14 = (r13 + 1) | 0;
                          r10 = 0;
                          heapClassInst.heap8[r13] = r10;
                          r10 = r12;
                          r12 = r14;
                          label = numDefine64;
                        } else {
                          r10 = r12;
                          r12 = r13;
                          label = numDefine64;
                        }
                      }
                    }
                    if (label === numDefine52) {
                      r10 = 0;
                    }
                    heapClassInst.heap32[r11] = r12;
                    r11 = twoEStr27248;
                    heapClassInst.heap32[g0] = r10;
                    heapClassInst.heap32[g0 + 1] = r11;
                    strcmp(i7);
                    r12 = commonVariable.rg0;
                    if (r12 === 0) {
                      label = numDefine66;
                    } else {
                      r12 = twoEStr28249;
                      heapClassInst.heap32[g0] = r12;
                      heapClassInst.heap32[g0 + 1] = r10;
                      heapClassInst.heap32[g0 + numDefine2] = r11;
                      printfError(i7);
                      label = numDefine66;
                    }
                  }
                }
              }
            } while (false);
            if (label === numDefine44) {
              heapClassInst.heap32[r11] = r10;
            }
            if (!(r9 < r4)) {
              break repeat28;
            }
          }
        }
      } while (false);
      heapClassInst.heap32[g0] = r5;
      free(i7);
    }
    mandreelInternalCreateWindow(i7);
    heapClassInst.heap32[g0] = 0;
    z30MandreelFopenEnableCheckfatb(i7);
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r2;
    fopen(i7);
    r0 = commonVariable.rg0;
    heapClassInst.heap32[g0] = 1;
    z30MandreelFopenEnableCheckfatb(i7);
    if (!(r0 === 0)) {
      if (uint(r0) < uint(numDefine10)) {
        r1 = zl13sFileStdout;
        r2 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine7];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = numDefine2;
        functionTable[r2 >> numDefine2](i7);
      } else {
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = numDefine2;
        functionTable[r1 >> numDefine2](i7);
        r1 = r0;
      }
      r2 = r1 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2 + numDefine5];
      heapClassInst.heap32[g0] = r1;
      functionTable[r2 >> numDefine2](i7);
      r1 = commonVariable.rg0;
      if (uint(r0) > uint(numDefine9)) {
        r2 = r0;
      } else {
        r2 = zl13sFileStdout;
      }
      r3 = r2 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine7];
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = 0;
      heapClassInst.heap32[g0 + numDefine2] = 0;
      functionTable[r3 >> numDefine2](i7);
      r2 = (r1 + 1) | 0;
      heapClassInst.heap32[g0] = r2;
      mallocNew(i7);
      r2 = commonVariable.rg0;
      if (uint(r0) < uint(numDefine10)) {
        r3 = zl13sFileStdout;
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + 1];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        r5 = 0;
        functionTable[r4 >> numDefine2](i7);
        heapClassInst.heap8[r2 + r1] = r5;
      } else {
        r3 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + 1];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        r4 = 0;
        functionTable[r3 >> numDefine2](i7);
        heapClassInst.heap8[r2 + r1] = r4;
        r3 = r0;
      }
      r4 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine4];
      heapClassInst.heap32[g0] = r3;
      functionTable[r4 >> numDefine2](i7);
      if (!(uint(r0) < uint(numDefine10))) {
        heapClassInst.heap32[g0] = r3;
        zdlPv(i7);
      }
      if (!(r2 === 0)) {
        r0 = (r2 + 1) | 0;
        r3 = -1;
        r4 = 0;
        r5 = r4;
        repeat278: while (true) {
          r6 = r3;
          repeat280: while (true) {
            if (r5 < r1) {
              r3 = (r2 + r5) | 0;
              r7 = heapClassInst.heapU8[r2 + r5];
              if (r7 === numDefine13) {
                r7 = r5;
              } else {
                repeat285: while (true) {
                  r7 = (r5 + 1) | 0;
                  r5 = heapClassInst.heapU8[r0 + r5];
                  if (r5 === numDefine13) {
                    break repeat285;
                  } else {
                    r5 = r7;
                    if (!(r7 < r1)) {
                      break repeat285;
                    }
                  }
                }
              }
              r5 = zl10strtokPos;
              r8 = 0;
              r9 = r5 >> numDefine2;
              heapClassInst.heap8[r2 + r7] = r8;
              r10 = heapClassInst.heap32[r9];
              r5 = (r7 + numDefine2) | 0;
              r3 = r3 === 0 ? r10 : r3;
              repeat289: while (true) {
                r7 = heapClassInst.heapU8[r3];
                if (r7 === 0) {
                  label = numDefine224;
                  break repeat289;
                } else {
                  r10 = r8;
                  repeat292: while (true) {
                    if (r10 === -1) {
                      label = numDefine214;
                      break repeat289;
                    } else {
                      r11 = twoEStr4133;
                      r11 = (r11 - r10) | 0;
                      r12 = r7 & numDefine255;
                      r11 = heapClassInst.heapU8[r11];
                      if (r12 !== r11) {
                        r10 = (r10 + -1) | 0;
                      } else {
                        break repeat292;
                      }
                    }
                  }
                  r3 = (r3 + 1) | 0;
                }
              }
              if (label === numDefine214) {
                if (!(r7 === 0)) {
                  r7 = r3;
                  repeat300: while (true) {
                    r8 = heapClassInst.heapU8[r7];
                    if (r8 === 0) {
                      break repeat300;
                    } else {
                      r10 = 1;
                      repeat303: while (true) {
                        if (r10 !== 0) {
                          r11 = twoEStr4133;
                          r11 = (r11 - r10) | 0;
                          r12 = r8 & numDefine255;
                          r11 = heapClassInst.heapU8[r11 + 1];
                          if (r12 === r11) {
                            break repeat300;
                          } else {
                            r10 = (r10 + -1) | 0;
                          }
                        } else {
                          break repeat303;
                        }
                      }
                      r7 = (r7 + 1) | 0;
                    }
                  }
                  r8 = heapClassInst.heapU8[r7];
                  if (r8 !== 0) {
                    r8 = (r7 + 1) | 0;
                    r10 = 0;
                    heapClassInst.heap8[r7] = r10;
                    r7 = r8;
                  }
                  heapClassInst.heap32[r9] = r7;
                  r8 = twoEStr3782;
                  heapClassInst.heap32[g0] = r8;
                  heapClassInst.heap32[g0 + 1] = r3;
                  strcmp(i7);
                  r8 = commonVariable.rg0;
                  if (r8 !== 0) {
                    r8 = twoEStr5784;
                    heapClassInst.heap32[g0] = r8;
                    heapClassInst.heap32[g0 + 1] = r3;
                    strcmp(i7);
                    r8 = commonVariable.rg0;
                    if (r8 !== 0) {
                      r7 = twoEStr6785;
                      heapClassInst.heap32[g0] = r7;
                      heapClassInst.heap32[g0 + 1] = r3;
                      r3 = -1;
                      strcmp(i7);
                      r7 = commonVariable.rg0;
                      if (r7 !== 0) {
                        continue repeat280;
                      } else {
                        continue repeat278;
                      }
                    } else {
                      break repeat280;
                    }
                  } else {
                    repeat315: while (true) {
                      r3 = heapClassInst.heapU8[r7];
                      if (r3 === 0) {
                        label = numDefine242;
                        break repeat315;
                      } else {
                        r8 = 0;
                        repeat318: while (true) {
                          if (r8 === -1) {
                            label = numDefine232;
                            break repeat315;
                          } else {
                            r10 = twoEStr4133;
                            r10 = (r10 - r8) | 0;
                            r11 = r3 & numDefine255;
                            r10 = heapClassInst.heapU8[r10];
                            if (r11 !== r10) {
                              r8 = (r8 + -1) | 0;
                            } else {
                              break repeat318;
                            }
                          }
                        }
                        r7 = (r7 + 1) | 0;
                      }
                    }
                    repeat323: do {
                      if (label === numDefine232) {
                        if (r3 === 0) {
                          label = numDefine242;
                        } else {
                          r3 = r7;
                          repeat326: while (true) {
                            r8 = heapClassInst.heapU8[r3];
                            if (r8 === 0) {
                              break repeat326;
                            } else {
                              r10 = 1;
                              repeat329: while (true) {
                                if (r10 !== 0) {
                                  r11 = twoEStr4133;
                                  r11 = (r11 - r10) | 0;
                                  r12 = r8 & numDefine255;
                                  r11 = heapClassInst.heapU8[r11 + 1];
                                  if (r12 === r11) {
                                    break repeat326;
                                  } else {
                                    r10 = (r10 + -1) | 0;
                                  }
                                } else {
                                  break repeat329;
                                }
                              }
                              r3 = (r3 + 1) | 0;
                            }
                          }
                          r8 = heapClassInst.heapU8[r3];
                          if (r8 !== 0) {
                            r8 = (r3 + 1) | 0;
                            r10 = 0;
                            heapClassInst.heap8[r3] = r10;
                            r3 = r8;
                          }
                          heapClassInst.heap32[r9] = r3;
                          repeat338: while (true) {
                            r8 = heapClassInst.heapU8[r3];
                            if (r8 === 0) {
                              label = numDefine260;
                              break repeat338;
                            } else {
                              r10 = 0;
                              repeat341: while (true) {
                                if (r10 === -1) {
                                  label = numDefine250;
                                  break repeat338;
                                } else {
                                  r11 = twoEStr4133;
                                  r11 = (r11 - r10) | 0;
                                  r12 = r8 & numDefine255;
                                  r11 = heapClassInst.heapU8[r11];
                                  if (r12 !== r11) {
                                    r10 = (r10 + -1) | 0;
                                  } else {
                                    break repeat341;
                                  }
                                }
                              }
                              r3 = (r3 + 1) | 0;
                            }
                          }
                          if (label === numDefine250) {
                            if (!(r8 === 0)) {
                              r8 = r3;
                              repeat349: while (true) {
                                r10 = heapClassInst.heapU8[r8];
                                if (r10 === 0) {
                                  break repeat349;
                                } else {
                                  r11 = 1;
                                  repeat352: while (true) {
                                    if (r11 !== 0) {
                                      r12 = twoEStr4133;
                                      r12 = (r12 - r11) | 0;
                                      r13 = r10 & numDefine255;
                                      r12 = heapClassInst.heapU8[r12 + 1];
                                      if (r13 === r12) {
                                        break repeat349;
                                      } else {
                                        r11 = (r11 + -1) | 0;
                                      }
                                    } else {
                                      break repeat352;
                                    }
                                  }
                                  r8 = (r8 + 1) | 0;
                                }
                              }
                              r10 = heapClassInst.heapU8[r8];
                              if (r10 !== 0) {
                                r10 = (r8 + 1) | 0;
                                r11 = 0;
                                heapClassInst.heap8[r8] = r11;
                                r8 = r10;
                              }
                              heapClassInst.heap32[r9] = r8;
                              repeat361: while (true) {
                                r10 = heapClassInst.heapU8[r8];
                                if (r10 === 0) {
                                  label = numDefine278;
                                  break repeat361;
                                } else {
                                  r11 = 0;
                                  repeat364: while (true) {
                                    if (r11 === -1) {
                                      label = numDefine268;
                                      break repeat361;
                                    } else {
                                      r12 = twoEStr4133;
                                      r12 = (r12 - r11) | 0;
                                      r13 = r10 & numDefine255;
                                      r12 = heapClassInst.heapU8[r12];
                                      if (r13 !== r12) {
                                        r11 = (r11 + -1) | 0;
                                      } else {
                                        break repeat364;
                                      }
                                    }
                                  }
                                  r8 = (r8 + 1) | 0;
                                }
                              }
                              if (label === numDefine268) {
                                if (!(r10 === 0)) {
                                  r10 = r8;
                                  repeat372: while (true) {
                                    r11 = heapClassInst.heapU8[r10];
                                    if (r11 === 0) {
                                      break repeat372;
                                    } else {
                                      r12 = 1;
                                      repeat375: while (true) {
                                        if (r12 !== 0) {
                                          r13 = twoEStr4133;
                                          r13 = (r13 - r12) | 0;
                                          r14 = r11 & numDefine255;
                                          r13 = heapClassInst.heapU8[r13 + 1];
                                          if (r14 === r13) {
                                            break repeat372;
                                          } else {
                                            r12 = (r12 + -1) | 0;
                                          }
                                        } else {
                                          break repeat375;
                                        }
                                      }
                                      r10 = (r10 + 1) | 0;
                                    }
                                  }
                                  r11 = heapClassInst.heapU8[r10];
                                  if (r11 !== 0) {
                                    r11 = (r10 + 1) | 0;
                                    r12 = 0;
                                    heapClassInst.heap8[r10] = r12;
                                    r10 = r11;
                                  }
                                  heapClassInst.heap32[r9] = r10;
                                  repeat384: while (true) {
                                    r11 = heapClassInst.heapU8[r10];
                                    if (r11 === 0) {
                                      label = numDefine296;
                                      break repeat384;
                                    } else {
                                      r12 = 0;
                                      repeat387: while (true) {
                                        if (r12 === -1) {
                                          label = numDefine286;
                                          break repeat384;
                                        } else {
                                          r13 = twoEStr4133;
                                          r13 = (r13 - r12) | 0;
                                          r14 = r11 & numDefine255;
                                          r13 = heapClassInst.heapU8[r13];
                                          if (r14 !== r13) {
                                            r12 = (r12 + -1) | 0;
                                          } else {
                                            break repeat387;
                                          }
                                        }
                                      }
                                      r10 = (r10 + 1) | 0;
                                    }
                                  }
                                  if (label === numDefine286) {
                                    if (!(r11 === 0)) {
                                      r11 = r10;
                                      repeat395: while (true) {
                                        r12 = heapClassInst.heapU8[r11];
                                        if (r12 === 0) {
                                          break repeat395;
                                        } else {
                                          r13 = 1;
                                          repeat398: while (true) {
                                            if (r13 !== 0) {
                                              r14 = twoEStr4133;
                                              r14 = (r14 - r13) | 0;
                                              r15 = r12 & numDefine255;
                                              r14 = heapClassInst.heapU8[r14 + 1];
                                              if (r15 === r14) {
                                                break repeat395;
                                              } else {
                                                r13 = (r13 + -1) | 0;
                                              }
                                            } else {
                                              break repeat398;
                                            }
                                          }
                                          r11 = (r11 + 1) | 0;
                                        }
                                      }
                                      r12 = heapClassInst.heapU8[r11];
                                      if (r12 !== 0) {
                                        r12 = (r11 + 1) | 0;
                                        r13 = 0;
                                        heapClassInst.heap8[r11] = r13;
                                        r11 = r12;
                                      }
                                      heapClassInst.heap32[r9] = r11;
                                      repeat407: while (true) {
                                        r12 = heapClassInst.heapU8[r11];
                                        if (r12 === 0) {
                                          label = numDefine314;
                                          break repeat407;
                                        } else {
                                          r13 = 0;
                                          repeat410: while (true) {
                                            if (r13 === -1) {
                                              label = numDefine304;
                                              break repeat407;
                                            } else {
                                              r14 = twoEStr4133;
                                              r14 = (r14 - r13) | 0;
                                              r15 = r12 & numDefine255;
                                              r14 = heapClassInst.heapU8[r14];
                                              if (r15 !== r14) {
                                                r13 = (r13 + -1) | 0;
                                              } else {
                                                break repeat410;
                                              }
                                            }
                                          }
                                          r11 = (r11 + 1) | 0;
                                        }
                                      }
                                      if (label === numDefine304) {
                                        if (!(r12 === 0)) {
                                          r12 = r11;
                                          repeat418: while (true) {
                                            r13 = heapClassInst.heapU8[r12];
                                            if (r13 === 0) {
                                              break repeat418;
                                            } else {
                                              r14 = 1;
                                              repeat421: while (true) {
                                                if (r14 !== 0) {
                                                  r15 = twoEStr4133;
                                                  r15 = (r15 - r14) | 0;
                                                  r16 = r13 & numDefine255;
                                                  r15 = heapClassInst.heapU8[r15 + 1];
                                                  if (r16 === r15) {
                                                    break repeat418;
                                                  } else {
                                                    r14 = (r14 + -1) | 0;
                                                  }
                                                } else {
                                                  break repeat421;
                                                }
                                              }
                                              r12 = (r12 + 1) | 0;
                                            }
                                          }
                                          r13 = heapClassInst.heapU8[r12];
                                          if (r13 !== 0) {
                                            r13 = (r12 + 1) | 0;
                                            r14 = 0;
                                            heapClassInst.heap8[r12] = r14;
                                            r12 = r13;
                                          }
                                          heapClassInst.heap32[r9] = r12;
                                          if (r8 === 0) {
                                            label = numDefine323;
                                            break repeat323;
                                          } else {
                                            if (r11 === 0) {
                                              label = numDefine323;
                                              break repeat323;
                                            } else {
                                              heapClassInst.heap32[g0] = numDefine284;
                                              znwj(i7);
                                              r9 = commonVariable.rg0;
                                              heapClassInst.heap32[g0] = r3;
                                              heapClassInst.heap32[g0 + 1] = 0;
                                              r3 = r9 >> numDefine2;
                                              strtol(i7);
                                              heapClassInst.heap32[r3 + numDefine65] = commonVariable.rg0;
                                              heapClassInst.heap32[g0] = r8;
                                              heapClassInst.heap32[g0 + 1] = 0;
                                              strtol(i7);
                                              heapClassInst.heap32[r3 + numDefine66] = commonVariable.rg0;
                                              heapClassInst.heap32[g0] = r10;
                                              heapClassInst.heap32[g0 + 1] = 0;
                                              strtol(i7);
                                              heapClassInst.heap32[r3 + numDefine67] = commonVariable.rg0;
                                              heapClassInst.heap32[g0] = r11;
                                              heapClassInst.heap32[g0 + 1] = 0;
                                              strtol(i7);
                                              heapClassInst.heap32[r3 + numDefine69] = commonVariable.rg0;
                                              r7 = (r7 + 1) | 0;
                                              r8 = 0;
                                              heapClassInst.heap32[r3 + numDefine68] = r4;
                                              heapClassInst.heap32[r3 + numDefine64] = r6;
                                              r3 = r9;
                                              repeat432: while (true) {
                                                r10 = heapClassInst.heapU8[r7];
                                                if (r10 === 0) {
                                                  break repeat432;
                                                } else {
                                                  r11 = r10 << numDefine24;
                                                  r11 = r11 >> numDefine24;
                                                  r11 = (r11 + numDefineNeg65) | 0;
                                                  r12 = numDefine26;
                                                  r13 = (r10 + numDefine32) | 0;
                                                  r10 = uint(r11) < uint(r12) ? r13 : r10;
                                                  r11 = r10 & numDefine255;
                                                  r12 = numDefine47;
                                                  r10 = r11 === numDefine92 ? r12 : r10;
                                                  r7 = (r7 + 1) | 0;
                                                  r11 = r10 & numDefine255;
                                                  if (!(r11 !== numDefine47)) {
                                                    r11 = r8 & numDefine255;
                                                    r8 = r10;
                                                    if (r11 === numDefine47) {
                                                      continue repeat432;
                                                    }
                                                  }
                                                  r8 = (r3 + 1) | 0;
                                                  heapClassInst.heap8[r3] = r10;
                                                  r3 = r8;
                                                  r8 = r10;
                                                }
                                              }
                                              r7 = zl24gPFirstTextureAsyncInfo;
                                              r8 = 0;
                                              r7 = r7 >> numDefine2;
                                              heapClassInst.heap8[r3] = r8;
                                              r3 = r9 >> numDefine2;
                                              r8 = heapClassInst.heap32[r7];
                                              heapClassInst.heap32[r3 + numDefine70] = r8;
                                              heapClassInst.heap32[r7] = r9;
                                              r3 = heapClassInst.heap32[r3 + numDefine69];
                                              r4 = (r3 + r4) | 0;
                                              continue repeat280;
                                            }
                                          }
                                        }
                                      }
                                      heapClassInst.heap32[r9] = r11;
                                      label = numDefine323;
                                      break repeat323;
                                    }
                                  }
                                  heapClassInst.heap32[r9] = r10;
                                  label = numDefine323;
                                  break repeat323;
                                }
                              }
                              heapClassInst.heap32[r9] = r8;
                              label = numDefine323;
                              break repeat323;
                            }
                          }
                          heapClassInst.heap32[r9] = r3;
                          label = numDefine323;
                        }
                      }
                    } while (false);
                    if (label === numDefine242) {
                      heapClassInst.heap32[r9] = r7;
                    }
                    r3 = twoEStr4783;
                    heapClassInst.heap32[g0] = r3;
                    printfWarning(i7);
                    continue repeat280;
                  }
                }
              }
              heapClassInst.heap32[r9] = r3;
            } else {
              break repeat278;
            }
          }
          repeat447: while (true) {
            r3 = heapClassInst.heapU8[r7];
            if (r3 === 0) {
              label = numDefine331;
              break repeat447;
            } else {
              r4 = 0;
              repeat450: while (true) {
                if (r4 === -1) {
                  label = numDefine332;
                  break repeat447;
                } else {
                  r8 = twoEStr4133;
                  r8 = (r8 - r4) | 0;
                  r10 = r3 & numDefine255;
                  r8 = heapClassInst.heapU8[r8];
                  if (r10 !== r8) {
                    r4 = (r4 + -1) | 0;
                  } else {
                    break repeat450;
                  }
                }
              }
              r7 = (r7 + 1) | 0;
            }
          }
          if (label === numDefine332) {
            if (r3 === 0) {
              label = numDefine331;
            } else {
              r3 = r7;
              repeat458: while (true) {
                r4 = heapClassInst.heapU8[r3];
                if (r4 === 0) {
                  break repeat458;
                } else {
                  r8 = 1;
                  repeat461: while (true) {
                    if (r8 !== 0) {
                      r10 = twoEStr4133;
                      r10 = (r10 - r8) | 0;
                      r11 = r4 & numDefine255;
                      r10 = heapClassInst.heapU8[r10 + 1];
                      if (r11 === r10) {
                        break repeat458;
                      } else {
                        r8 = (r8 + -1) | 0;
                      }
                    } else {
                      break repeat461;
                    }
                  }
                  r3 = (r3 + 1) | 0;
                }
              }
              r4 = heapClassInst.heapU8[r3];
              if (r4 !== 0) {
                r8 = (r3 + 1) | 0;
                r4 = 0;
                heapClassInst.heap8[r3] = r4;
                r4 = r7;
                r7 = r8;
                label = numDefine343;
              } else {
                r4 = r7;
                r7 = r3;
                label = numDefine343;
              }
            }
          }
          if (label === numDefine331) {
            r4 = 0;
          }
          heapClassInst.heap32[r9] = r7;
          repeat473: while (true) {
            r3 = heapClassInst.heapU8[r7];
            if (r3 === 0) {
              label = numDefine359;
              break repeat473;
            } else {
              r8 = 0;
              repeat476: while (true) {
                if (r8 === -1) {
                  label = numDefine350;
                  break repeat473;
                } else {
                  r10 = twoEStr4133;
                  r10 = (r10 - r8) | 0;
                  r11 = r3 & numDefine255;
                  r10 = heapClassInst.heapU8[r10];
                  if (r11 !== r10) {
                    r8 = (r8 + -1) | 0;
                  } else {
                    break repeat476;
                  }
                }
              }
              r7 = (r7 + 1) | 0;
            }
          }
          if (label === numDefine350) {
            if (!(r3 === 0)) {
              repeat483: while (true) {
                r3 = heapClassInst.heapU8[r7];
                if (r3 === 0) {
                  break repeat483;
                } else {
                  r8 = 1;
                  repeat486: while (true) {
                    if (r8 !== 0) {
                      r10 = twoEStr4133;
                      r10 = (r10 - r8) | 0;
                      r11 = r3 & numDefine255;
                      r10 = heapClassInst.heapU8[r10 + 1];
                      if (r11 === r10) {
                        break repeat483;
                      } else {
                        r8 = (r8 + -1) | 0;
                      }
                    } else {
                      break repeat486;
                    }
                  }
                  r7 = (r7 + 1) | 0;
                }
              }
              r3 = heapClassInst.heapU8[r7];
              if (r3 !== 0) {
                r3 = (r7 + 1) | 0;
                r8 = 0;
                heapClassInst.heap8[r7] = r8;
                r7 = r3;
              }
            }
          }
          r3 = (r6 + 1) | 0;
          heapClassInst.heap32[r9] = r7;
          r7 = heapClassInst.heapU8[r4];
          repeat494: do {
            if (r7 === 0) {
              r8 = 1;
            } else {
              r7 = 1;
              while (true) {
                r8 = (r7 + 1) | 0;
                r9 = heapClassInst.heapU8[r4 + r7];
                r7 = r8;
                if (!(r9 !== 0)) {
                  break repeat494;
                }
              }
            }
          } while (false);
          r7 = zl17gApPackFileNames;
          r6 = r6 << numDefine2;
          r6 = (r7 + r6) | 0;
          heapClassInst.heap32[g0] = r8;
          r6 = r6 >> numDefine2;
          znaj(i7);
          heapClassInst.heap32[r6 + 1] = commonVariable.rg0;
          heapClassInst.heap32[g0] = commonVariable.rg0;
          heapClassInst.heap32[g0 + 1] = r4;
          r4 = 0;
          strcpy(i7);
        }
        heapClassInst.heap32[g0] = r2;
        free(i7);
      }
    }
    r0 = sp + numDefineNeg2440;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = 0;
    r1 = zgvz21MandreelGetTickCountE7sFirst;
    getTimeOfDay(i7);
    r2 = heapClassInst.heapU8[r1];
    if (!(r2 !== 0)) {
      r2 = heapClassInst.heap32[fp + numDefineNeg610];
      r3 = r2 >> numDefine31;
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r3;
      heapClassInst.heap32[g0 + numDefine2] = numDefineN6;
      heapClassInst.heap32[g0 + numDefine3] = 0;
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + 1];
      muldi3(i7);
      r4 = 1;
      r5 = (commonVariable.rg0 + r0) | 0;
      r6 = 0;
      r7 = r0 >> numDefine31;
      r2 = uint(r5) < uint(commonVariable.rg0) ? r4 : r6;
      r6 = zz21MandreelGetTickCountE7sFirst;
      r3 = (commonVariable.rg1 + r7) | 0;
      r0 = uint(r5) < uint(r0) ? r4 : r2;
      r2 = r6 >> numDefine2;
      r0 = (r3 + r0) | 0;
      heapClassInst.heap32[r2] = r5;
      heapClassInst.heap32[r2 + 1] = r0;
      heapClassInst.heap8[r1] = r4;
    }
    return;
  } else {
    r2 = twoEStr34255;
    r0 = twoEStr1222;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = numDefine307;
    assertNew(i7);
  }
}

function keyEvent(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function mouseDoubleClick(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function mouseMove(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function mouseButton(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function mouseWheelDelta(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function printfError(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16408;
  let g0 = i7 >> numDefine2;
  r0 = (sp + numDefine4) | 0;
  heapClassInst.heap32[fp + numDefineNeg4097] = r0;
  r1 = sp + numDefineNeg16384;
  r2 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine16384;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  r0 = gMsgcallback;
  r0 = r0 >> numDefine2;
  vsnprintf(i7);
  r0 = heapClassInst.heap32[r0];
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r1;
    sandboxOutputDebugString(i7);
  }
  return;
}

function printfWarning(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16408;
  let g0 = i7 >> numDefine2;
  r0 = (sp + numDefine4) | 0;
  heapClassInst.heap32[fp + numDefineNeg4097] = r0;
  r1 = sp + numDefineNeg16384;
  r2 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine16384;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  r0 = gMsgcallback;
  r0 = r0 >> numDefine2;
  vsnprintf(i7);
  r0 = heapClassInst.heap32[r0];
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r1;
    sandboxOutputDebugString(i7);
  }
  return;
}

function mandreelInternalPreupdate(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg8;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = 0;
  r1 = zgvz21MandreelGetTickCountE7sFirst;
  getTimeOfDay(i7);
  r2 = heapClassInst.heapU8[r1];
  if (!(r2 !== 0)) {
    r2 = heapClassInst.heap32[fp + numDefineNeg2];
    r3 = r2 >> numDefine31;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = numDefineN6;
    heapClassInst.heap32[g0 + numDefine3] = 0;
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + 1];
    muldi3(i7);
    r4 = 1;
    r5 = (commonVariable.rg0 + r0) | 0;
    r6 = 0;
    r7 = r0 >> numDefine31;
    r2 = uint(r5) < uint(commonVariable.rg0) ? r4 : r6;
    r6 = zz21MandreelGetTickCountE7sFirst;
    r3 = (commonVariable.rg1 + r7) | 0;
    r0 = uint(r5) < uint(r0) ? r4 : r2;
    r2 = r6 >> numDefine2;
    r0 = (r3 + r0) | 0;
    heapClassInst.heap32[r2] = r5;
    heapClassInst.heap32[r2 + 1] = r0;
    heapClassInst.heap8[r1] = r4;
  }
  r0 = zz29MandreelInternalPreupdateE8sBfirst2EB;
  r1 = heapClassInst.heapU8[r0];
  if (!(r1 !== 0)) {
    r1 = 1;
    heapClassInst.heap8[r0] = r1;
  }
  return;
}

function mandreelInternalUpdate(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = numDefineNeg32788;
  repeat1: while (true) {
    r1 = zl10sASockets;
    r1 = (r1 - r0) | 0;
    r2 = heapClassInst.heapU8[r1];
    if (!(r2 === 0)) {
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = numDefine2048;
      jsMandreelFlashTcpUpdate(i7);
    }
    r0 = (r0 + numDefineNeg32792) | 0;
    if (r0 !== numDefineNeg95124) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  r0 = zl7gBInit2EB;
  r1 = heapClassInst.heapU8[r0];
  if (r1 !== 0) {
    mandreelAudioUpdate(i7);
    r1 = sp + numDefineNeg8;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = 0;
    getTimeOfDay(i7);
    r2 = heapClassInst.heap32[fp + numDefineNeg2];
    r3 = r2 >> numDefine31;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = numDefineN6;
    heapClassInst.heap32[g0 + numDefine3] = 0;
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + 1];
    muldi3(i7);
    r4 = (commonVariable.rg0 + r1) | 0;
    r5 = 1;
    r6 = 0;
    r7 = r1 >> numDefine31;
    r2 = uint(r4) < uint(commonVariable.rg0) ? r5 : r6;
    r3 = (commonVariable.rg1 + r7) | 0;
    r1 = uint(r4) < uint(r1) ? r5 : r2;
    r1 = (r3 + r1) | 0;
    r2 = zgvz21MandreelGetTickCountE7sFirst;
    r3 = heapClassInst.heapU8[r2];
    if (!(r3 !== 0)) {
      r3 = zz21MandreelGetTickCountE7sFirst;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      heapClassInst.heap32[r3 + 1] = r1;
      heapClassInst.heap8[r2] = r5;
    }
    r2 = zz21MandreelGetTickCountE7sFirst;
    r2 = r2 >> numDefine2;
    r3 = heapClassInst.heap32[r2];
    r2 = heapClassInst.heap32[r2 + 1];
    r1 = (r1 - r2) | 0;
    r2 = uint(r4) < uint(r3) ? r5 : r6;
    r3 = (r4 - r3) | 0;
    r1 = (r1 - r2) | 0;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine1000;
    heapClassInst.heap32[g0 + numDefine3] = 0;
    udivdi3(i7);
    r1 = commonVariable.rg0;
    r2 = zl11gAChannels;
    repeat12: while (true) {
      if (r6 < numDefine32) {
        r3 = r2 >> numDefine2;
        r4 = heapClassInst.heap32[r3 + numDefine72];
        if (!(r4 !== 1)) {
          r4 = zl11gAChannels;
          r7 = (r6 * numDefine292) | 0;
          r4 = (r4 + r7) | 0;
          r7 = heapClassInst.heapU8[r4 + numDefine268];
          if (!(r7 !== 0)) {
            r7 = heapClassInst.heap32[r3 + numDefine71];
            if (r7 === -1) {
              r7 = heapClassInst.heapU8[r0];
              if (r7 !== 1) {
                label = numDefine14;
                break repeat12;
              } else {
                r7 = zl21gPFirstSoundDuration;
                repeat21: while (true) {
                  r7 = r7 >> numDefine2;
                  r7 = heapClassInst.heap32[r7];
                  if (r7 !== 0) {
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r2;
                    strcmp(i7);
                    r8 = commonVariable.rg0;
                    if (r8 !== 0) {
                      r7 = (r7 + numDefine260) | 0;
                    } else {
                      label = numDefine16;
                      break repeat21;
                    }
                  } else {
                    label = numDefine19;
                    break repeat21;
                  }
                }
                switch (label) {
                  case numDefine19:
                    r7 = twoEStr3224;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r2;
                    r7 = 0;
                    printfWarning(i7);
                    break;
                  case numDefine16:
                    r7 = r7 >> numDefine2;
                    r7 = heapClassInst.heap32[r7 + numDefine64];
                    break;
                  default:
                    break;
                }
                heapClassInst.heap32[r3 + numDefine71] = r7;
              }
            }
            r8 = heapClassInst.heap32[r3 + numDefine70];
            r7 = (r8 + r7) | 0;
            if (!(uint(r7) > uint(r1))) {
              r7 = heapClassInst.heapU8[r0];
              if (r7 !== 0) {
                r7 = (r6 + -1) | 0;
                if (!(uint(r7) > uint(numDefine30))) {
                  r7 = heapClassInst.heapU8[r4 + numDefine269];
                  if (!(r7 !== 0)) {
                    if (!(uint(r6) > uint(numDefine31))) {
                      r7 = heapClassInst.heap32[r3 + numDefine68];
                      r8 = heapClassInst.heap32[r3 + numDefine69];
                      heapClassInst.heap32[g0] = r2;
                      heapClassInst.heap32[g0 + 1] = r8;
                      heapClassInst.heap32[g0 + numDefine2] = r7;
                      mandreelAudioStopChannel(i7);
                      heapClassInst.heap32[r3 + numDefine72] = 0;
                      heapClassInst.heap32[r3 + numDefine68] = -1;
                    }
                    r3 = zl15gIFreeChannels;
                    r3 = r3 >> numDefine2;
                    heapClassInst.heap8[r4 + numDefine269] = r5;
                    r4 = heapClassInst.heap32[r3];
                    r7 = (r4 + -1) | 0;
                    repeat37: do {
                      if (!(r7 < 0)) {
                        r7 = r4;
                        while (true) {
                          r8 = zl15gAFreeChannels;
                          r9 = r7 << numDefine2;
                          r8 = (r8 + r9) | 0;
                          r8 = r8 >> numDefine2;
                          r9 = heapClassInst.heap32[r8 + -1];
                          r7 = (r7 + -1) | 0;
                          heapClassInst.heap32[r8] = r9;
                          if (!(r7 !== 0)) {
                            break repeat37;
                          }
                        }
                      }
                    } while (false);
                    r7 = zl15gAFreeChannels;
                    r7 = r7 >> numDefine2;
                    r4 = (r4 + 1) | 0;
                    heapClassInst.heap32[r7] = r6;
                    heapClassInst.heap32[r3] = r4;
                  }
                }
              } else {
                label = numDefine23;
                break repeat12;
              }
            }
          }
        }
        r6 = (r6 + 1) | 0;
        r2 = (r2 + numDefine292) | 0;
      } else {
        label = numDefine34;
        break repeat12;
      }
    }
    switch (label) {
      case numDefine34:
        return;
      case numDefine14:
        r7 = twoEStr221;
        r0 = twoEStr1222;
        heapClassInst.heap32[g0] = r7;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = numDefine341;
        assertNew(i7);
        break;
      case numDefine23:
        r0 = twoEStr221;
        r1 = twoEStr1222;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine621;
        assertNew(i7);
        break;
      default:
        break;
    }
  } else {
    r0 = twoEStr221;
    r1 = twoEStr1222;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine361;
    assertNew(i7);
  }
}

function forceSuperLink(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  mandreelInternalInit(i7);
  r0 = sp + numDefineNeg8;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = 0;
  r1 = zgvz21MandreelGetTickCountE7sFirst;
  getTimeOfDay(i7);
  r2 = heapClassInst.heapU8[r1];
  if (!(r2 !== 0)) {
    r2 = heapClassInst.heap32[fp + numDefineNeg2];
    r3 = r2 >> numDefine31;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = numDefineN6;
    heapClassInst.heap32[g0 + numDefine3] = 0;
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + 1];
    muldi3(i7);
    r4 = 1;
    r5 = (commonVariable.rg0 + r0) | 0;
    r6 = 0;
    r7 = r0 >> numDefine31;
    r2 = uint(r5) < uint(commonVariable.rg0) ? r4 : r6;
    r6 = zz21MandreelGetTickCountE7sFirst;
    r3 = (commonVariable.rg1 + r7) | 0;
    r0 = uint(r5) < uint(r0) ? r4 : r2;
    r2 = r6 >> numDefine2;
    r0 = (r3 + r0) | 0;
    heapClassInst.heap32[r2] = r5;
    heapClassInst.heap32[r2 + 1] = r0;
    heapClassInst.heap8[r1] = r4;
  }
  r0 = zz29MandreelInternalPreupdateE8sBfirst2EB;
  r1 = heapClassInst.heapU8[r0];
  if (!(r1 !== 0)) {
    r1 = 1;
    heapClassInst.heap8[r0] = r1;
  }
  return;
}

function znk10Cxxabiv117ClassTypeInfo11DoUpcastEPKS0PPv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg16;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg4] = 0;
  heapClassInst.heap32[r1 + 1] = 0;
  r2 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r1 + numDefine2] = numDefine16;
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  r4 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r4 = r4 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine5];
  r5 = heapClassInst.heap32[r4];
  r6 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r6;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  functionTable[r3 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r1 + 1];
  r0 = r0 & numDefine6;
  if (r0 !== numDefine6) {
    r0 = 0;
    commonVariable.rg0 = r0;
    return;
  } else {
    r0 = heapClassInst.heap32[fp + numDefineNeg4];
    heapClassInst.heap32[r4] = r0;
    r0 = 1;
    commonVariable.rg0 = r0;
    return;
  }
}

function znk10Cxxabiv117ClassTypeInfo20DoFindPublicSrcEiPKvPKS0S2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine4];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = numDefine6;
  r3 = 1;
  r0 = r0 === r1 ? r2 : r3;
  commonVariable.rg0 = r0;
  return;
}

function znkst9typeInfo10DoCatchEPKSPPvj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[r1 + 1];
  r2 = twoEStr26;
  r0 = r0 === 0 ? r2 : r0;
  r1 = r1 === 0 ? r2 : r1;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  strcmp(i7);
  r2 = commonVariable.rg0;
  if (r2 < 0) {
    r0 = 0;
    commonVariable.rg0 = r0;
    return;
  } else {
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    strcmp(i7);
    r0 = commonVariable.rg0 >>> numDefine31;
    r0 = r0 ^ 1;
    commonVariable.rg0 = r0;
    return;
  }
}

function zn10Cxxabiv117ClassTypeInfoD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn10Cxxabiv117ClassTypeInfoD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znk10Cxxabiv117ClassTypeInfo10DoCatchEPKSt9typeInfoPPvj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[r1 + 1];
  r2 = twoEStr26;
  r0 = r0 === 0 ? r2 : r0;
  r1 = r1 === 0 ? r2 : r1;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  strcmp(i7);
  r2 = commonVariable.rg0;
  if (r2 > -1) {
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    r0 = -1;
    strcmp(i7);

    r0 = commonVariable.rg0 > r0 ? 1 : 0;
  } else {
    r0 = 0;
  }
  r0 = r0 & 1;
  commonVariable.rg0 = r0;
  return;
}

function znk10Cxxabiv117ClassTypeInfo11DoUpcastEPKS0PKvRNS015UpcastResultE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[r1 + 1];
  r2 = twoEStr26;
  r0 = r0 === 0 ? r2 : r0;
  r1 = r1 === 0 ? r2 : r1;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  strcmp(i7);
  r2 = commonVariable.rg0;
  if (!(r2 < 0)) {
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    strcmp(i7);
    r0 = commonVariable.rg0;
    if (!(r0 < 0)) {
      r0 = heapClassInst.heap32[fp + numDefine2];
      r1 = heapClassInst.heap32[fp + numDefine3];
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r1] = r0;
      heapClassInst.heap32[r1 + numDefine3] = numDefine8;
      heapClassInst.heap32[r1 + 1] = numDefine6;
      r0 = 1;
      commonVariable.rg0 = r0;
      return;
    }
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk10Cxxabiv117ClassTypeInfo12DoDyncastEiNS010SubKindEPKS0PKvS3S5RNS016DyncastResultE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine4];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine7];
  r0 = heapClassInst.heap32[r0 + 1];
  r4 = heapClassInst.heap32[fp + numDefine6];
  if (!(r1 !== r4)) {
    r4 = heapClassInst.heap32[fp + numDefine5];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + 1];
    r5 = twoEStr26;
    r4 = r4 === 0 ? r5 : r4;
    r5 = r0 === 0 ? r5 : r0;
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r4;
    strcmp(i7);
    r6 = commonVariable.rg0;
    if (!(r6 < 0)) {
      heapClassInst.heap32[g0] = r4;
      heapClassInst.heap32[g0 + 1] = r5;
      strcmp(i7);
      r4 = commonVariable.rg0;
      if (r4 > -1) {
        r1 = r3 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine2] = r2;
        r1 = 0;
        commonVariable.rg0 = r1;
        return;
      }
    }
  }
  r4 = heapClassInst.heap32[fp + numDefine3];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + 1];
  r5 = twoEStr26;
  r4 = r4 === 0 ? r5 : r4;
  r0 = r0 === 0 ? r5 : r0;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r4;
  strcmp(i7);
  r5 = commonVariable.rg0;
  if (!(r5 < 0)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r0;
    strcmp(i7);
    r0 = commonVariable.rg0;
    if (!(r0 < 0)) {
      r0 = r3 >> numDefine2;
      heapClassInst.heap32[r0] = r1;
      heapClassInst.heap32[r0 + 1] = r2;
      heapClassInst.heap32[r0 + numDefine3] = 1;
    }
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn10Cxxabiv120SiClassTypeInfoD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn10Cxxabiv120SiClassTypeInfoD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znk10Cxxabiv120SiClassTypeInfo11DoUpcastEPKNS17ClassTypeInfoEPKvRNS115UpcastResultE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + 1];
  r3 = heapClassInst.heap32[r1 + 1];
  r4 = twoEStr26;
  r2 = r2 === 0 ? r4 : r2;
  r3 = r3 === 0 ? r4 : r3;
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r2;
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  strcmp(i7);
  r6 = commonVariable.rg0;
  if (!(r6 < 0)) {
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    strcmp(i7);
    r2 = commonVariable.rg0;
    if (r2 > -1) {
      r0 = r5 >> numDefine2;
      heapClassInst.heap32[r0] = r4;
      heapClassInst.heap32[r0 + numDefine3] = numDefine8;
      heapClassInst.heap32[r0 + 1] = numDefine6;
      r0 = 1;
      commonVariable.rg0 = r0;
      return;
    }
  }
  r1 = heapClassInst.heap32[r1 + numDefine2];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine5];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  heapClassInst.heap32[g0 + numDefine3] = r5;
  functionTable[r2 >> numDefine2](i7);
  return;
}

function znk10Cxxabiv120SiClassTypeInfo12DoDyncastEiNS17ClassTypeInfo10SubKindEPKS1PKvS4S6RNS116DyncastResultE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + 1];
  r3 = heapClassInst.heap32[r1 + 1];
  r4 = twoEStr26;
  r2 = r2 === 0 ? r4 : r2;
  r3 = r3 === 0 ? r4 : r3;
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r2;
  r5 = heapClassInst.heap32[fp + 1];
  r6 = heapClassInst.heap32[fp + numDefine2];
  r7 = heapClassInst.heap32[fp + numDefine4];
  r8 = heapClassInst.heap32[fp + numDefine6];
  r9 = heapClassInst.heap32[fp + numDefine7];
  strcmp(i7);
  r10 = commonVariable.rg0;
  if (r10 < 0) {
    label = numDefine6;
  } else {
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    strcmp(i7);
    r2 = commonVariable.rg0;
    if (r2 < 0) {
      label = numDefine6;
    } else {
      r0 = r9 >> numDefine2;
      heapClassInst.heap32[r0] = r7;
      heapClassInst.heap32[r0 + 1] = r6;
      if (r5 < 0) {
        if (r5 !== numDefineNeg2) {
          label = numDefine11;
        } else {
          heapClassInst.heap32[r0 + numDefine3] = 1;
          label = numDefine11;
        }
      } else {
        r1 = (r7 + r5) | 0;
        r3 = numDefine6;
        r4 = 1;
        r1 = r1 === r8 ? r3 : r4;
        heapClassInst.heap32[r0 + numDefine3] = r1;
        label = numDefine11;
      }
    }
  }
  repeat8: do {
    if (label === numDefine6) {
      r2 = heapClassInst.heap32[fp + numDefine5];
      if (!(r7 !== r8)) {
        r10 = r2 >> numDefine2;
        r10 = heapClassInst.heap32[r10 + 1];
        r4 = r10 === 0 ? r4 : r10;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r4;
        strcmp(i7);
        r10 = commonVariable.rg0;
        if (!(r10 < 0)) {
          heapClassInst.heap32[g0] = r4;
          heapClassInst.heap32[g0 + 1] = r3;
          strcmp(i7);
          r3 = commonVariable.rg0;
          if (r3 > -1) {
            r0 = r9 >> numDefine2;
            heapClassInst.heap32[r0 + numDefine2] = r6;
            break repeat8;
          }
        }
      }
      r1 = heapClassInst.heap32[r1 + numDefine2];
      r3 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine6];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r5;
      heapClassInst.heap32[g0 + numDefine2] = r6;
      heapClassInst.heap32[g0 + numDefine3] = r0;
      heapClassInst.heap32[g0 + numDefine4] = r7;
      heapClassInst.heap32[g0 + numDefine5] = r2;
      heapClassInst.heap32[g0 + numDefine6] = r8;
      heapClassInst.heap32[g0 + numDefine7] = r9;
      functionTable[r3 >> numDefine2](i7);
      return;
    }
  } while (false);
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk10Cxxabiv120SiClassTypeInfo20DoFindPublicSrcEiPKvPKNS17ClassTypeInfoES2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine4];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + numDefine3];
  if (!(r0 !== r1)) {
    r4 = r3 >> numDefine2;
    r5 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + 1];
    r5 = heapClassInst.heap32[r5 + 1];
    r6 = twoEStr26;
    r4 = r4 === 0 ? r6 : r4;
    r5 = r5 === 0 ? r6 : r5;
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r4;
    strcmp(i7);
    r6 = commonVariable.rg0;
    if (!(r6 < 0)) {
      heapClassInst.heap32[g0] = r4;
      heapClassInst.heap32[g0 + 1] = r5;
      strcmp(i7);
      r4 = commonVariable.rg0;
      if (r4 > -1) {
        r0 = numDefine6;
        commonVariable.rg0 = r0;
        return;
      }
    }
  }
  r4 = heapClassInst.heap32[fp + 1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine2];
  r5 = r2 >> numDefine2;
  r5 = heapClassInst.heap32[r5];
  r5 = r5 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine7];
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  heapClassInst.heap32[g0 + numDefine4] = r0;
  functionTable[r5 >> numDefine2](i7);
  return;
}

function znk10Cxxabiv121VmiClassTypeInfo11DoUpcastEPKNS17ClassTypeInfoEPKvRNS115UpcastResultE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 >> numDefine2;
  r3 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + 1];
  r4 = heapClassInst.heap32[r3 + 1];
  r5 = twoEStr26;
  r2 = r2 === 0 ? r5 : r2;
  r4 = r4 === 0 ? r5 : r4;
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r2;
  r6 = heapClassInst.heap32[fp + numDefine2];
  r7 = heapClassInst.heap32[fp + numDefine3];
  strcmp(i7);
  r8 = commonVariable.rg0;
  if (r8 < 0) {
    label = numDefine3;
  } else {
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r4;
    strcmp(i7);
    r2 = commonVariable.rg0;
    if (r2 < 0) {
      label = numDefine3;
    } else {
      r0 = r7 >> numDefine2;
      heapClassInst.heap32[r0] = r6;
      heapClassInst.heap32[r0 + numDefine3] = numDefine8;
      heapClassInst.heap32[r0 + 1] = numDefine6;
      label = numDefine39;
    }
  }
  repeat4: do {
    if (label === numDefine3) {
      r2 = r7 >> numDefine2;
      r4 = heapClassInst.heap32[r2 + numDefine2];
      r7 = r4 & numDefine16;
      if (r7 !== 0) {
        r4 = heapClassInst.heap32[r3 + numDefine2];
      }
      r3 = heapClassInst.heap32[r3 + numDefine3];
      r7 = r4 & 1;
      r3 = (r3 + 1) | 0;
      repeat9: while (true) {
        if (r3 !== 1) {
          r8 = sp + numDefineNeg16;
          r9 = r8 >> numDefine2;
          heapClassInst.heap32[fp + numDefineNeg4] = 0;
          r10 = r3 << numDefine3;
          heapClassInst.heap32[r9 + 1] = 0;
          r10 = (r1 + r10) | 0;
          heapClassInst.heap32[r9 + numDefine2] = r4;
          r10 = r10 >> numDefine2;
          heapClassInst.heap32[r9 + numDefine3] = 0;
          r10 = heapClassInst.heap32[r10 + 1];
          r11 = r10 & numDefine2;
          if (r7 !== 0) {
            label = numDefine9;
          } else {
            r12 = r11 >>> 1;
            if (r12 !== 0) {
              label = numDefine9;
            } else {
              label = numDefine8;
            }
          }
          if (label === numDefine9) {
            r12 = r3 << 1;
            r13 = r10 & 1;
            if (r6 !== 0) {
              r10 = r10 >> numDefine8;
              if (r13 !== 0) {
                r14 = r6 >> numDefine2;
                r14 = heapClassInst.heap32[r14];
                r10 = (r14 + r10) | 0;
                r10 = r10 >> numDefine2;
                r10 = heapClassInst.heap32[r10];
              }
              r10 = (r6 + r10) | 0;
            } else {
              r10 = 0;
            }
            r12 = r12 << numDefine2;
            r12 = (r1 + r12) | 0;
            r12 = r12 >> numDefine2;
            r14 = heapClassInst.heap32[r12];
            r15 = r14 >> numDefine2;
            r15 = heapClassInst.heap32[r15];
            r15 = r15 >> numDefine2;
            r15 = heapClassInst.heap32[r15 + numDefine5];
            heapClassInst.heap32[g0] = r14;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r10;
            heapClassInst.heap32[g0 + numDefine3] = r8;
            functionTable[r15 >> numDefine2](i7);
            r8 = commonVariable.rg0;
            if (!(r8 === 0)) {
              r8 = heapClassInst.heap32[r9 + numDefine3];
              if (!(r8 !== numDefine8)) {
                if (r13 !== 0) {
                  r8 = heapClassInst.heap32[r12];
                  heapClassInst.heap32[r9 + numDefine3] = r8;
                }
              }
              r10 = heapClassInst.heap32[r9 + 1];
              if (!(r10 < numDefine4)) {
                if (r11 === 0) {
                  r10 = r10 & numDefineNeg3;
                  heapClassInst.heap32[r9 + 1] = r10;
                }
              }
              r11 = heapClassInst.heap32[r2 + numDefine3];
              if (r11 !== 0) {
                r9 = heapClassInst.heap32[r2];
                r12 = heapClassInst.heap32[fp + numDefineNeg4];
                if (r9 === r12) {
                  if (r9 === 0) {
                    if (r8 === numDefine8) {
                      label = numDefine35;
                      break repeat9;
                    } else {
                      if (r11 === numDefine8) {
                        label = numDefine35;
                        break repeat9;
                      } else {
                        r9 = r11 >> numDefine2;
                        r8 = r8 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + 1];
                        r8 = heapClassInst.heap32[r8 + 1];
                        r9 = r9 === 0 ? r5 : r9;
                        r8 = r8 === 0 ? r5 : r8;
                        heapClassInst.heap32[g0] = r8;
                        heapClassInst.heap32[g0 + 1] = r9;
                        strcmp(i7);
                        r11 = commonVariable.rg0;
                        if (r11 < 0) {
                          label = numDefine35;
                          break repeat9;
                        } else {
                          heapClassInst.heap32[g0] = r9;
                          heapClassInst.heap32[g0 + 1] = r8;
                          strcmp(i7);
                          r8 = commonVariable.rg0;
                          if (r8 > -1) {
                            r8 = heapClassInst.heap32[r2 + 1];
                            r8 = r10 | r8;
                            heapClassInst.heap32[r2 + 1] = r8;
                          } else {
                            label = numDefine35;
                            break repeat9;
                          }
                        }
                      }
                    }
                  } else {
                    r8 = heapClassInst.heap32[r2 + 1];
                    r8 = r10 | r8;
                    heapClassInst.heap32[r2 + 1] = r8;
                  }
                } else {
                  label = numDefine28;
                  break repeat9;
                }
              } else {
                r11 = heapClassInst.heap32[fp + numDefineNeg4];
                heapClassInst.heap32[r2] = r11;
                heapClassInst.heap32[r2 + 1] = r10;
                r11 = heapClassInst.heap32[r9 + numDefine2];
                heapClassInst.heap32[r2 + numDefine2] = r11;
                heapClassInst.heap32[r2 + numDefine3] = r8;
                if (r10 < numDefine4) {
                  break repeat4;
                } else {
                  r8 = r10 & numDefine2;
                  if (r8 === 0) {
                    r8 = r10 & 1;
                    if (r8 === 0) {
                      break repeat4;
                    } else {
                      r8 = heapClassInst.heapU8[r1 + numDefine8];
                      r8 = r8 & numDefine2;
                      if (r8 === 0) {
                        break repeat4;
                      }
                    }
                  } else {
                    r8 = heapClassInst.heapU8[r1 + numDefine8];
                    r8 = r8 & 1;
                    if (r8 === 0) {
                      break repeat4;
                    }
                  }
                }
              }
            }
          }
          r3 = (r3 + -1) | 0;
          continue repeat9;
        } else {
          label = numDefine38;
          break repeat9;
        }
      }
      switch (label) {
        case numDefine38:
          r0 = heapClassInst.heap32[r2 + 1];
          r1 = 0;

          r0 = r0 !== r1 ? 1 : 0;
          r0 = r0 & 1;
          commonVariable.rg0 = r0;
          return;
        case numDefine28:
          heapClassInst.heap32[r2] = 0;
          break;
        default:
          break;
      }
      heapClassInst.heap32[r2 + 1] = numDefine2;
    }
  } while (false);
  r0 = 1;
  commonVariable.rg0 = r0;
  return;
}

function znk10Cxxabiv121VmiClassTypeInfo12DoDyncastEiNS17ClassTypeInfo10SubKindEPKS1PKvS4S6RNS116DyncastResultE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg56;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine7];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine4];
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  r6 = heapClassInst.heap32[fp + numDefine4];
  r7 = heapClassInst.heap32[fp + numDefine5];
  r8 = heapClassInst.heap32[fp + numDefine6];
  r9 = r1 & numDefine16;
  if (r9 !== 0) {
    r1 = r2 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine2];
    heapClassInst.heap32[r0 + numDefine4] = r1;
  }
  r9 = r2 >> numDefine2;
  r10 = heapClassInst.heap32[r9 + 1];
  if (r6 !== r8) {
    label = numDefine5;
  } else {
    r11 = r7 >> numDefine2;
    r11 = heapClassInst.heap32[r11 + 1];
    r12 = twoEStr26;
    r11 = r11 === 0 ? r12 : r11;
    r12 = r10 === 0 ? r12 : r10;
    heapClassInst.heap32[g0] = r12;
    heapClassInst.heap32[g0 + 1] = r11;
    strcmp(i7);
    r13 = commonVariable.rg0;
    if (r13 < 0) {
      label = numDefine5;
    } else {
      heapClassInst.heap32[g0] = r11;
      heapClassInst.heap32[g0 + 1] = r12;
      strcmp(i7);
      r11 = commonVariable.rg0;
      if (r11 > -1) {
        heapClassInst.heap32[r0 + numDefine2] = r4;
        label = numDefine8;
      } else {
        label = numDefine5;
      }
    }
  }
  repeat8: do {
    if (label === numDefine5) {
      r11 = r5 >> numDefine2;
      r12 = heapClassInst.heap32[r11 + 1];
      r13 = twoEStr26;
      r12 = r12 === 0 ? r13 : r12;
      r10 = r10 === 0 ? r13 : r10;
      heapClassInst.heap32[g0] = r10;
      heapClassInst.heap32[g0 + 1] = r12;
      strcmp(i7);
      r13 = commonVariable.rg0;
      if (r13 < 0) {
        label = numDefine14;
      } else {
        heapClassInst.heap32[g0] = r12;
        heapClassInst.heap32[g0 + 1] = r10;
        strcmp(i7);
        r10 = commonVariable.rg0;
        if (r10 < 0) {
          label = numDefine14;
        } else {
          heapClassInst.heap32[r0] = r6;
          heapClassInst.heap32[r0 + 1] = r4;
          if (r3 < 0) {
            if (r3 === numDefineNeg2) {
              heapClassInst.heap32[r0 + numDefine3] = 1;
              r9 = 0;
              commonVariable.rg0 = r9;
              return;
            } else {
              label = numDefine12;
            }
          } else {
            r1 = (r6 + r3) | 0;
            r2 = numDefine6;
            r3 = 1;
            r1 = r1 === r8 ? r2 : r3;
            heapClassInst.heap32[r0 + numDefine3] = r1;
            break repeat8;
          }
        }
      }
      repeat17: do {
        if (label === numDefine14) {
          r10 = heapClassInst.heap32[r9 + numDefine3];
          r12 = r1 & numDefine2;
          r9 = 0;
          r13 = r1;
          repeat19: while (true) {
            r14 = r13 & numDefine3;
            repeat21: while (true) {
              r15 = r9;
              r9 = r10 << numDefine3;
              r9 = (r2 + r9) | 0;
              r20 = 0;
              repeat23: while (true) {
                r16 = r20;
                if (r10 !== r16) {
                  r17 = sp + numDefineNeg24;
                  r18 = r17 >> numDefine2;
                  heapClassInst.heap32[fp + numDefineNeg6] = 0;
                  heapClassInst.heap32[r18 + 1] = 0;
                  heapClassInst.heap32[r18 + numDefine2] = 0;
                  r19 = r16 << numDefine3;
                  r19 = (r9 - r19) | 0;
                  heapClassInst.heap32[r18 + numDefine3] = 0;
                  r19 = r19 >> numDefine2;
                  heapClassInst.heap32[r18 + numDefine4] = r13;
                  r20 = heapClassInst.heap32[r19 + numDefine3];
                  r21 = r20 & 1;
                  r22 = r20 >> numDefine8;
                  if (r21 !== 0) {
                    r23 = r6 >> numDefine2;
                    r23 = heapClassInst.heap32[r23];
                    r22 = (r23 + r22) | 0;
                    r22 = r22 >> numDefine2;
                    r22 = heapClassInst.heap32[r22];
                  }
                  r20 = r20 & numDefine2;
                  if (r20 === 0) {
                    if (r3 !== numDefineNeg2) {
                      label = numDefine21;
                      break repeat23;
                    } else {
                      r20 = (r16 + 1) | 0;
                      if (r14 === 0) {
                        continue repeat23;
                      } else {
                        label = numDefine21;
                        break repeat23;
                      }
                    }
                  } else {
                    label = numDefine18;
                    break repeat23;
                  }
                } else {
                  label = numDefine77;
                  break repeat19;
                }
              }
              switch (label) {
                case numDefine21:
                  r9 = r4 & numDefineNeg3;
                  break;
                case numDefine18:
                  r9 = r4;
                  break;
                default:
                  break;
              }
              r20 = heapClassInst.heap32[r19 + numDefine2];
              r19 = r20 >> numDefine2;
              r19 = heapClassInst.heap32[r19];
              r19 = r19 >> numDefine2;
              r19 = heapClassInst.heap32[r19 + numDefine6];
              r9 = r21 | r9;
              r21 = (r6 + r22) | 0;
              heapClassInst.heap32[g0] = r20;
              heapClassInst.heap32[g0 + 1] = r3;
              heapClassInst.heap32[g0 + numDefine2] = r9;
              heapClassInst.heap32[g0 + numDefine3] = r5;
              heapClassInst.heap32[g0 + numDefine4] = r21;
              heapClassInst.heap32[g0 + numDefine5] = r7;
              heapClassInst.heap32[g0 + numDefine6] = r8;
              heapClassInst.heap32[g0 + numDefine7] = r17;
              functionTable[r19 >> numDefine2](i7);
              r9 = commonVariable.rg0;
              r20 = heapClassInst.heap32[r0 + numDefine2];
              r17 = heapClassInst.heap32[r18 + numDefine2];
              r20 = r17 | r20;
              heapClassInst.heap32[r0 + numDefine2] = r20;
              r17 = heapClassInst.heap32[r18 + numDefine3];
              if (r17 === numDefine2) {
                label = numDefine24;
                break repeat19;
              } else {
                if (r17 !== numDefine6) {
                  r19 = (r10 + -1) | 0;
                  r10 = heapClassInst.heap32[r0];
                  r21 = r15 & numDefine255;
                  if (r21 !== 0) {
                    label = numDefine30;
                    break repeat21;
                  } else {
                    if (r10 !== 0) {
                      label = numDefine31;
                      break repeat21;
                    } else {
                      r10 = heapClassInst.heap32[fp + numDefineNeg6];
                      heapClassInst.heap32[r0] = r10;
                      r15 = heapClassInst.heap32[r18 + 1];
                      heapClassInst.heap32[r0 + 1] = r15;
                      if (r10 !== 0) {
                        r10 = (r19 - r16) | 0;
                        if (r20 === 0) {
                          continue repeat21;
                        } else {
                          label = numDefine29;
                          break repeat21;
                        }
                      } else {
                        label = numDefine73;
                        break repeat21;
                      }
                    }
                  }
                } else {
                  label = numDefine24;
                  break repeat19;
                }
              }
            }
            repeat40: do {
              switch (label) {
                case numDefine30:
                  if (r10 === 0) {
                    r14 = heapClassInst.heap32[fp + numDefineNeg6];
                    r10 = 0;
                    label = numDefine36;
                    break repeat40;
                  } else {
                    label = numDefine31;
                    break repeat40;
                  }
                case numDefine29:
                  r10 = heapClassInst.heapU8[r2 + numDefine8];
                  r10 = r10 & 1;
                  if (r10 !== 0) {
                    label = numDefine73;
                  } else {
                    label = numDefine78;
                    break repeat17;
                  }
                  break;
                default:
                  break;
              }
            } while (false);
            if (label === numDefine31) {
              r14 = heapClassInst.heap32[fp + numDefineNeg6];
              if (r10 !== r14) {
                if (r14 !== 0) {
                  label = numDefine39;
                } else {
                  if (r9 === 0) {
                    label = numDefine36;
                  } else {
                    label = numDefine39;
                  }
                }
              } else {
                r9 = heapClassInst.heap32[r0 + 1];
                r10 = heapClassInst.heap32[r18 + 1];
                r9 = r10 | r9;
                heapClassInst.heap32[r0 + 1] = r9;
                r9 = r15;
                label = numDefine73;
              }
            }
            repeat50: do {
              if (label === numDefine36) {
                if (!(r14 === 0)) {
                  if (!(r21 === 0)) {
                    label = numDefine39;
                    break repeat50;
                  }
                }
                r9 = r15;
                label = numDefine73;
              }
            } while (false);
            if (label === numDefine39) {
              r9 = heapClassInst.heap32[r0 + numDefine3];
              repeat57: do {
                if (r20 > numDefine3) {
                  r14 = r20 & 1;
                  if (!(r14 === 0)) {
                    if (!(r12 === 0)) {
                      r13 = r1;
                      label = numDefine43;
                      break repeat57;
                    }
                  }
                  r13 = r14 === 0 ? r13 : r1;
                  r10 = 1;
                  r9 = r9 === 0 ? r10 : r9;
                  if (r17 === 0) {
                    r17 = r10;
                    label = numDefine64;
                  } else {
                    label = numDefine64;
                  }
                } else {
                  label = numDefine43;
                }
              } while (false);
              repeat64: do {
                if (label === numDefine43) {
                  if (r9 < 1) {
                    repeat68: do {
                      if (!(r17 < numDefine4)) {
                        r9 = r17 & 1;
                        if (r9 !== 0) {
                          r9 = heapClassInst.heapU8[r2 + numDefine8];
                          r9 = r9 & numDefine2;
                          if (!(r9 === 0)) {
                            break repeat68;
                          }
                        }
                        r9 = 1;
                        break repeat64;
                      }
                    } while (false);
                    if (r3 < 0) {
                      if (r3 !== numDefineNeg2) {
                        r9 = heapClassInst.heap32[r11];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine7];
                        heapClassInst.heap32[g0] = r5;
                        heapClassInst.heap32[g0 + 1] = r3;
                        heapClassInst.heap32[g0 + numDefine2] = r10;
                        heapClassInst.heap32[g0 + numDefine3] = r7;
                        heapClassInst.heap32[g0 + numDefine4] = r8;
                        functionTable[r9 >> numDefine2](i7);
                        r9 = commonVariable.rg0;
                      } else {
                        r9 = 1;
                      }
                    } else {
                      r9 = (r10 + r3) | 0;
                      r10 = numDefine6;
                      r14 = 1;
                      r9 = r9 === r8 ? r10 : r14;
                    }
                  }
                  if (r17 < 1) {
                    if (r9 < numDefine4) {
                      label = numDefine60;
                    } else {
                      r10 = r9 & 1;
                      if (r10 !== 0) {
                        r10 = heapClassInst.heapU8[r2 + numDefine8];
                        r10 = r10 & numDefine2;
                        if (r10 === 0) {
                          label = numDefine58;
                        } else {
                          label = numDefine60;
                        }
                      } else {
                        label = numDefine58;
                      }
                    }
                    if (label === numDefine60) {
                      r10 = heapClassInst.heap32[fp + numDefineNeg6];
                      if (r3 < 0) {
                        if (!(r3 === numDefineNeg2)) {
                          r14 = heapClassInst.heap32[r11];
                          r14 = r14 >> numDefine2;
                          r14 = heapClassInst.heap32[r14 + numDefine7];
                          heapClassInst.heap32[g0] = r5;
                          heapClassInst.heap32[g0 + 1] = r3;
                          heapClassInst.heap32[g0 + numDefine2] = r10;
                          heapClassInst.heap32[g0 + numDefine3] = r7;
                          heapClassInst.heap32[g0 + numDefine4] = r8;
                          functionTable[r14 >> numDefine2](i7);
                          r17 = commonVariable.rg0;
                          break repeat64;
                        }
                      } else {
                        r10 = (r10 + r3) | 0;
                        r14 = numDefine6;
                        r17 = 1;
                        r17 = r10 === r8 ? r14 : r17;
                        break repeat64;
                      }
                    }
                    r17 = 1;
                  }
                }
              } while (false);
              r10 = r9 ^ r17;
              if (r10 < numDefine4) {
                r9 = r9 & r17;
                heapClassInst.heap32[r0] = 0;
                if (r9 < numDefine4) {
                  r9 = 1;
                  heapClassInst.heap32[r0 + numDefine3] = 1;
                } else {
                  label = numDefine71;
                  break repeat19;
                }
              } else {
                if (r17 > numDefine3) {
                  r9 = heapClassInst.heap32[fp + numDefineNeg6];
                  heapClassInst.heap32[r0] = r9;
                  r9 = heapClassInst.heap32[r18 + 1];
                  r15 = 0;
                  heapClassInst.heap32[r0 + 1] = r9;
                  r9 = r17;
                }
                heapClassInst.heap32[r0 + numDefine3] = r9;
                r10 = r9 & numDefine2;
                if (r10 !== 0) {
                  label = numDefine12;
                  break repeat17;
                } else {
                  r9 = r9 & 1;
                  if (r9 === 0) {
                    label = numDefine12;
                    break repeat17;
                  } else {
                    r9 = r15;
                  }
                }
              }
            }
            r10 = (r19 - r16) | 0;
            if (r20 !== numDefine4) {
              continue repeat19;
            } else {
              label = numDefine78;
              break repeat17;
            }
          }
          switch (label) {
            case numDefine24:
              r20 = heapClassInst.heap32[fp + numDefineNeg6];
              heapClassInst.heap32[r0] = r20;
              r20 = heapClassInst.heap32[r18 + 1];
              heapClassInst.heap32[r0 + 1] = r20;
              heapClassInst.heap32[r0 + numDefine3] = r17;
              commonVariable.rg0 = r9;
              return;
            case numDefine71:
              heapClassInst.heap32[r0 + numDefine3] = numDefine3;
              r9 = 1;
              commonVariable.rg0 = r9;
              return;
            case numDefine77:
              r9 = r15;
              label = numDefine78;
              break;
            default:
              break;
          }
        }
      } while (false);
      if (label === numDefine12) {
        r9 = 0;
      }
      r0 = r9 & numDefine255;
      commonVariable.rg0 = r0;
      return;
    }
  } while (false);
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk10Cxxabiv121VmiClassTypeInfo20DoFindPublicSrcEiPKvPKNS17ClassTypeInfoES2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + numDefine4];
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + numDefine3];
  if (r0 !== r1) {
    label = numDefine4;
  } else {
    r4 = r3 >> numDefine2;
    r5 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + 1];
    r5 = heapClassInst.heap32[r5 + 1];
    r6 = twoEStr26;
    r4 = r4 === 0 ? r6 : r4;
    r5 = r5 === 0 ? r6 : r5;
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r4;
    strcmp(i7);
    r6 = commonVariable.rg0;
    if (r6 < 0) {
      label = numDefine4;
    } else {
      heapClassInst.heap32[g0] = r4;
      heapClassInst.heap32[g0 + 1] = r5;
      strcmp(i7);
      r4 = commonVariable.rg0;
      if (r4 < 0) {
        label = numDefine4;
      } else {
        r0 = numDefine6;
        label = numDefine15;
      }
    }
  }
  if (label === numDefine4) {
    r4 = heapClassInst.heap32[fp + 1];
    r5 = r2 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine3];
    r5 = (r5 + 1) | 0;
    repeat7: while (true) {
      if (r5 !== 1) {
        r6 = r5 << numDefine3;
        r6 = (r2 + r6) | 0;
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + 1];
        r7 = r6 & numDefine2;
        repeat10: do {
          if (r7 !== 0) {
            r7 = r6 & 1;
            if (!(r7 === 0)) {
              if (r4 === numDefineNeg3) {
                break repeat10;
              }
            }
            r8 = r5 << 1;
            r6 = r6 >> numDefine8;
            if (r7 !== 0) {
              r9 = r0 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r6 = (r9 + r6) | 0;
              r6 = r6 >> numDefine2;
              r6 = heapClassInst.heap32[r6];
            }
            r8 = r8 << numDefine2;
            r8 = (r2 + r8) | 0;
            r8 = r8 >> numDefine2;
            r8 = heapClassInst.heap32[r8];
            r9 = r8 >> numDefine2;
            r9 = heapClassInst.heap32[r9];
            r9 = r9 >> numDefine2;
            r9 = heapClassInst.heap32[r9 + numDefine7];
            r6 = (r0 + r6) | 0;
            heapClassInst.heap32[g0] = r8;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r6;
            heapClassInst.heap32[g0 + numDefine3] = r3;
            heapClassInst.heap32[g0 + numDefine4] = r1;
            functionTable[r9 >> numDefine2](i7);
            r6 = commonVariable.rg0;
            if (!(r6 < numDefine4)) {
              label = numDefine12;
              break repeat7;
            }
          }
        } while (false);
        r5 = (r5 + -1) | 0;
        continue repeat7;
      } else {
        label = numDefine14;
        break repeat7;
      }
    }
    switch (label) {
      case numDefine14:
        r0 = 1;
        break;
      case numDefine12:
        r0 = r6 | r7;
        commonVariable.rg0 = r0;
        return;
      default:
        break;
    }
  }
  commonVariable.rg0 = r0;
  return;
}

function zn10Cxxabiv121VmiClassTypeInfoD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn10Cxxabiv121VmiClassTypeInfoD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvst9typeInfo;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function extendsfdf2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 & numDefine83647;
  r2 = r0 & numDefineNeg83648;
  r3 = (r1 + numDefineNeg88608) | 0;
  if (uint(r3) > uint(numDefine06431)) {
    if (uint(r1) < uint(numDefine95040)) {
      if (r1 !== 0) {
        r0 = r1 >>> 1;
        r0 = r1 | r0;
        r3 = r0 >>> numDefine2;
        r0 = r0 | r3;
        r3 = r0 >>> numDefine4;
        r0 = r0 | r3;
        r3 = r0 >>> numDefine8;
        r0 = r0 | r3;
        r3 = r0 >>> numDefine16;
        r0 = r0 | r3;
        r3 = r0 ^ -1;
        r4 = numDefine55765;
        r3 = r3 >>> 1;
        r0 = r4 & ~r0;
        r3 = r3 & numDefine55765;
        r0 = (r0 + r3) | 0;
        r3 = r0 >>> numDefine2;
        r0 = r0 & numDefine93459;
        r3 = r3 & numDefine93459;
        r0 = (r0 + r3) | 0;
        r3 = r0 >>> numDefine4;
        r0 = r0 & numDefine45135;
        r3 = r3 & numDefine45135;
        r0 = (r0 + r3) | 0;
        r3 = r0 >>> numDefine8;
        r0 = r0 & numDefine11935;
        r3 = r3 & numDefine11935;
        r0 = (r0 + r3) | 0;
        r3 = r0 & numDefine65535;
        r0 = r0 >>> numDefine16;
        r0 = (r3 + r0) | 0;
        r3 = (r0 + numDefine21) | 0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        r3 = numDefine905;
        ashldi3(i7);
        r1 = commonVariable.rg0;
        r0 = (r3 - r0) | 0;
        r3 = commonVariable.rg1 ^ numDefine48576;
        r0 = r0 << numDefine20;
        r0 = r3 | r0;
      } else {
        r1 = 0;
        r0 = r1;
      }
    } else {
      r1 = r0 >>> numDefine3;
      r3 = r1 & numDefine24288;
      r1 = r0 & numDefine94303;
      r0 = r3 | numDefine35072;
    }
  } else {
    r0 = r1 >>> numDefine3;
    r1 = r1 << numDefine29;
    r0 = (r0 + numDefine24096) | 0;
  }
  r3 = sp + numDefineNeg8;
  r3 = r3 >> numDefine2;
  r0 = r0 | r2;
  heapClassInst.heap32[fp + numDefineNeg2] = r1;
  heapClassInst.heap32[r3 + 1] = r0;
  f0 = llvmReadDouble(sp + numDefineNeg8);
  commonVariable.fg0 = f0;
  return;
}

function fixdfsi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = sp + 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = r0 >>> numDefine20;
  r1 = r1 & numDefine2047;
  r2 = r0 & numDefine48575;
  r3 = -1;
  r4 = 1;
  r5 = (r1 + numDefineNeg1023) | 0;
  r0 = r0 < 0 ? r3 : r4;
  r3 = heapClassInst.heap32[fp];
  r2 = r2 | numDefine48576;
  if (uint(r5) > uint(numDefine51)) {
    if (r5 < 0) {
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    } else {
      r1 = (r1 + numDefineNeg1075) | 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r2;
      heapClassInst.heap32[g0 + numDefine2] = r1;
      ashldi3(i7);
    }
  } else {
    r5 = numDefine1075;
    r1 = (r5 - r1) | 0;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r1;
    lshrdi3(i7);
  }
  heapClassInst.heap32[g0] = commonVariable.rg0;
  heapClassInst.heap32[g0 + 1] = commonVariable.rg1;
  heapClassInst.heap32[g0 + numDefine2] = r0;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  muldi3(i7);
  return;
}

function floatsidf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (r0 !== 0) {
    r1 = r0 >> numDefine31;
    r2 = (r0 + r1) | 0;
    r1 = r2 ^ r1;
    r2 = r1 >>> 1;
    r2 = r1 | r2;
    r3 = r2 >>> numDefine2;
    r2 = r2 | r3;
    r3 = r2 >>> numDefine4;
    r2 = r2 | r3;
    r3 = r2 >>> numDefine8;
    r2 = r2 | r3;
    r3 = r2 >>> numDefine16;
    r2 = r2 | r3;
    r3 = r2 ^ -1;
    r4 = numDefine55765;
    r3 = r3 >>> 1;
    r2 = r4 & ~r2;
    r3 = r3 & numDefine55765;
    r2 = (r2 + r3) | 0;
    r3 = r2 >>> numDefine2;
    r2 = r2 & numDefine93459;
    r3 = r3 & numDefine93459;
    r2 = (r2 + r3) | 0;
    r3 = r2 >>> numDefine4;
    r2 = r2 & numDefine45135;
    r3 = r3 & numDefine45135;
    r2 = (r2 + r3) | 0;
    r3 = r2 >>> numDefine8;
    r2 = r2 & numDefine11935;
    r3 = r3 & numDefine11935;
    r2 = (r2 + r3) | 0;
    r3 = r2 & numDefine65535;
    r2 = r2 >>> numDefine16;
    r4 = numDefine31;
    r2 = (r3 + r2) | 0;
    r3 = numDefine52;
    r4 = (r4 - r2) | 0;
    r3 = (r3 - r4) | 0;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = 0;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    r1 = numDefine1054;
    ashldi3(i7);
    r1 = (r1 - r2) | 0;
    r2 = commonVariable.rg1 ^ numDefine48576;
    r1 = r1 << numDefine20;
    r4 = sp + numDefineNeg8;
    r1 = (r2 + r1) | 0;
    r0 = r0 & numDefineNeg83648;
    r2 = r4 >> numDefine2;
    r0 = r1 | r0;
    heapClassInst.heap32[fp + numDefineNeg2] = commonVariable.rg0;
    heapClassInst.heap32[r2 + 1] = r0;
    f0 = llvmReadDouble(sp + numDefineNeg8);
    commonVariable.fg0 = f0;
    return;
  } else {
    f0 = 0;
    commonVariable.fg0 = f0;
    return;
  }
}

function floatunsidf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (r0 !== 0) {
    r1 = r0 >>> 1;
    r1 = r0 | r1;
    r2 = r1 >>> numDefine2;
    r1 = r1 | r2;
    r2 = r1 >>> numDefine4;
    r1 = r1 | r2;
    r2 = r1 >>> numDefine8;
    r1 = r1 | r2;
    r2 = r1 >>> numDefine16;
    r1 = r1 | r2;
    r2 = r1 ^ -1;
    r3 = numDefine55765;
    r2 = r2 >>> 1;
    r1 = r3 & ~r1;
    r2 = r2 & numDefine55765;
    r1 = (r1 + r2) | 0;
    r2 = r1 >>> numDefine2;
    r1 = r1 & numDefine93459;
    r2 = r2 & numDefine93459;
    r1 = (r1 + r2) | 0;
    r2 = r1 >>> numDefine4;
    r1 = r1 & numDefine45135;
    r2 = r2 & numDefine45135;
    r1 = (r1 + r2) | 0;
    r2 = r1 >>> numDefine8;
    r1 = r1 & numDefine11935;
    r2 = r2 & numDefine11935;
    r1 = (r1 + r2) | 0;
    r2 = r1 & numDefine65535;
    r1 = r1 >>> numDefine16;
    r3 = numDefine31;
    r1 = (r2 + r1) | 0;
    r2 = numDefine52;
    r3 = (r3 - r1) | 0;
    r2 = (r2 - r3) | 0;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = 0;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    r0 = numDefine1054;
    ashldi3(i7);
    r0 = (r0 - r1) | 0;
    r1 = sp + numDefineNeg8;
    r3 = commonVariable.rg1 ^ numDefine48576;
    r0 = r0 << numDefine20;
    r1 = r1 >> numDefine2;
    r0 = (r3 + r0) | 0;
    heapClassInst.heap32[fp + numDefineNeg2] = commonVariable.rg0;
    heapClassInst.heap32[r1 + 1] = r0;
    f0 = llvmReadDouble(sp + numDefineNeg8);
    commonVariable.fg0 = f0;
    return;
  } else {
    f0 = 0;
    commonVariable.fg0 = f0;
    return;
  }
}

function truncdfsf2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = sp + 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = r0 & numDefine83647;
  r2 = heapClassInst.heap32[fp];
  r3 = (r1 + numDefineNeg72672) | 0;
  r4 = (r1 + numDefineNeg10976) | 0;
  repeat1: do {
    if (uint(r3) >= uint(r4)) {
      r3 = 0;
      r4 = numDefine35072;

      r5 = r2 === r3 ? 1 : 0;

      r4 = uint(r1) < uint(r4) ? 1 : 0;
      r4 = r1 === numDefine35072 ? r5 : r4;
      if (r4 !== 0) {
        r4 = numDefine10976;

        r4 = uint(r1) < uint(r4) ? 1 : 0;
        r4 = r1 === numDefine10976 ? r5 : r4;
        if (r4 !== 0) {
          r4 = numDefine897;
          r1 = r1 >>> numDefine20;
          r1 = (r4 - r1) | 0;
          if (r1 < numDefine53) {
            r4 = r0 & numDefine48575;
            r4 = r4 | numDefine48576;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r1;
            lshrdi3(i7);
            r5 = commonVariable.rg0;
            r6 = commonVariable.rg1;
            r7 = numDefine64;
            r1 = (r7 - r1) | 0;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r1;
            ashldi3(i7);
            r1 = commonVariable.rg0 | commonVariable.rg1;

            r1 = r1 !== r3 ? 1 : 0;
            r1 = r1 & 1;
            r2 = r5 & numDefine70911;
            r4 = r5 >>> numDefine29;
            r5 = r6 << numDefine3;
            r1 = r1 | r2;
            r2 = r4 | r5;
            if (uint(r1) < uint(numDefine35457)) {
              r1 = r1 ^ numDefine35456;
              r3 = r1 | r3;
              if (r3 === 0) {
                r3 = r2 & 1;
                r3 = (r3 + r2) | 0;
              } else {
                r3 = r2;
              }
            } else {
              r3 = (r2 + 1) | 0;
            }
          } else {
            break repeat1;
          }
        } else {
          r3 = numDefine95040;
        }
      } else {
        r1 = r2 & numDefine94303;
        r3 = r1 | numDefine89344;
      }
    } else {
      r1 = r2 >>> numDefine29;
      r3 = r0 << numDefine3;
      r1 = r1 | r3;
      r2 = r2 & numDefine70911;
      if (uint(r2) < uint(numDefine35457)) {
        r3 = (r1 + numDefine41824) | 0;
        r1 = 0;
        r2 = r2 ^ numDefine35456;
        r1 = r2 | r1;
        if (r1 === 0) {
          r1 = r3 & 1;
          r3 = (r1 + r3) | 0;
        }
      } else {
        r3 = (r1 + numDefine41825) | 0;
      }
    }
  } while (false);
  r0 = r0 & numDefineNeg83648;
  r0 = r3 | r0;
  heapClassInst.heap32[fp + -1] = r0;
  f0 = heapClassInst.heapFloat[fp + -1];
  commonVariable.fg0 = f0;
  return;
}

function fixunsdfsi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = sp + 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = r0 >>> numDefine20;
  r1 = r1 & numDefine2047;
  r2 = (r1 + numDefineNeg1023) | 0;
  if (!(r2 < 0)) {
    if (!(r0 < 0)) {
      r2 = heapClassInst.heap32[fp];
      r2 = r2 >>> numDefine21;
      r0 = r0 << numDefine11;
      r0 = r2 | r0;
      r2 = numDefine1054;
      r0 = r0 | numDefineNeg83648;
      r1 = (r2 - r1) | 0;
      r0 = r0 >>> r1;
      commonVariable.rg0 = r0;
      return;
    }
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function floatundisf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 | r1;
  if (r2 === 0) {
    f0 = 0;
    commonVariable.fg0 = f0;
    return;
  } else {
    r2 = r0 >>> 1;
    r3 = r1 >>> 1;
    r2 = r0 | r2;
    r3 = r1 | r3;
    r4 = r2 >>> numDefine2;
    r5 = r3 >>> numDefine2;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 >>> numDefine4;
    r5 = r3 >>> numDefine4;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 >>> numDefine8;
    r5 = r3 >>> numDefine8;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 >>> numDefine16;
    r5 = r3 >>> numDefine16;
    r2 = r2 | r4;
    r3 = r3 | r5;
    r4 = r2 ^ -1;
    r5 = numDefine55765;
    r6 = r3 ^ -1;
    r4 = r4 >>> 1;
    r6 = r6 >>> 1;
    r2 = r5 & ~r2;
    r4 = r4 & numDefine55765;
    r2 = (r2 + r4) | 0;
    r3 = r5 & ~r3;
    r4 = r6 & numDefine55765;
    r3 = (r3 + r4) | 0;
    r4 = r2 >>> numDefine2;
    r5 = r3 >>> numDefine2;
    r2 = r2 & numDefine93459;
    r4 = r4 & numDefine93459;
    r2 = (r2 + r4) | 0;
    r3 = r3 & numDefine93459;
    r4 = r5 & numDefine93459;
    r3 = (r3 + r4) | 0;
    r4 = r2 >>> numDefine4;
    r5 = r3 >>> numDefine4;
    r2 = r2 & numDefine45135;
    r4 = r4 & numDefine45135;
    r2 = (r2 + r4) | 0;
    r3 = r3 & numDefine45135;
    r4 = r5 & numDefine45135;
    r3 = (r3 + r4) | 0;
    r4 = r2 >>> numDefine8;
    r5 = r3 >>> numDefine8;
    r2 = r2 & numDefine11935;
    r4 = r4 & numDefine11935;
    r2 = (r2 + r4) | 0;
    r3 = r3 & numDefine11935;
    r4 = r5 & numDefine11935;
    r3 = (r3 + r4) | 0;
    r4 = r2 & numDefine65535;
    r2 = r2 >>> numDefine16;
    r2 = (r4 + r2) | 0;
    r4 = r3 & numDefine65535;
    r3 = r3 >>> numDefine16;
    r3 = (r4 + r3) | 0;
    r2 = (r2 + numDefine32) | 0;
    r4 = numDefine64;
    r2 = r1 !== 0 ? r3 : r2;
    r3 = numDefine63;
    r4 = (r4 - r2) | 0;
    r2 = (r3 - r2) | 0;
    if (r4 < numDefine25) {
      r3 = numDefine24;
      r3 = (r3 - r4) | 0;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r3;
      ashldi3(i7);
      r1 = commonVariable.rg0;
    } else {
      if (r4 === numDefine25) {
        r1 = r1 << 1;
        r3 = r0 >>> numDefine31;
        r0 = r0 << 1;
        r1 = r1 | r3;
      } else {
        if (r4 !== numDefine26) {
          r3 = (r4 + numDefineNeg26) | 0;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = r3;
          lshrdi3(i7);
          r3 = commonVariable.rg0;
          r5 = commonVariable.rg1;
          r6 = numDefine90;
          r6 = (r6 - r4) | 0;
          heapClassInst.heap32[g0] = -1;
          heapClassInst.heap32[g0 + 1] = -1;
          heapClassInst.heap32[g0 + numDefine2] = r6;
          lshrdi3(i7);
          r0 = commonVariable.rg0 & r0;
          r1 = commonVariable.rg1 & r1;
          r0 = r0 | r1;
          r1 = 0;

          r0 = r0 !== r1 ? 1 : 0;
          r0 = r0 & 1;
          r0 = r0 | r3;
          r1 = r5;
        }
      }
      r3 = r0 >>> numDefine2;
      r3 = r3 & 1;
      r0 = r3 | r0;
      r3 = (r0 + 1) | 0;
      r5 = 1;
      r6 = 0;
      r0 = uint(r3) < uint(r0) ? r5 : r6;
      r0 = r3 === 0 ? r5 : r0;
      r0 = (r1 + r0) | 0;
      r1 = r3 >>> numDefine2;
      r5 = r0 << numDefine30;
      r1 = r1 | r5;
      r5 = r1 & numDefine77216;
      if (r5 !== 0) {
        r1 = r3 >>> numDefine3;
        r0 = r0 << numDefine29;
        r1 = r1 | r0;
        r2 = r4;
      }
    }
    r0 = r2 << numDefine23;
    r0 = (r0 + numDefine53216) | 0;
    r1 = r1 & numDefine88607;
    r0 = r0 | r1;
    heapClassInst.heap32[fp + -1] = r0;
    f0 = heapClassInst.heapFloat[fp + -1];
    commonVariable.fg0 = f0;
    return;
  }
}

function floatdisf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 | r1;
  if (r2 === 0) {
    f0 = 0;
    commonVariable.fg0 = f0;
    return;
  } else {
    r2 = r1 >> numDefine31;
    r1 = r2 ^ r1;
    r0 = r2 ^ r0;
    r3 = 1;
    r4 = 0;
    r5 = (r0 - r2) | 0;
    r1 = (r1 - r2) | 0;
    r0 = uint(r0) < uint(r2) ? r3 : r4;
    r0 = (r1 - r0) | 0;
    r1 = r5 >>> 1;
    r6 = r0 >>> 1;
    r1 = r5 | r1;
    r6 = r0 | r6;
    r7 = r1 >>> numDefine2;
    r8 = r6 >>> numDefine2;
    r1 = r1 | r7;
    r6 = r6 | r8;
    r7 = r1 >>> numDefine4;
    r8 = r6 >>> numDefine4;
    r1 = r1 | r7;
    r6 = r6 | r8;
    r7 = r1 >>> numDefine8;
    r8 = r6 >>> numDefine8;
    r1 = r1 | r7;
    r6 = r6 | r8;
    r7 = r1 >>> numDefine16;
    r8 = r6 >>> numDefine16;
    r1 = r1 | r7;
    r6 = r6 | r8;
    r7 = r1 ^ -1;
    r8 = numDefine55765;
    r9 = r6 ^ -1;
    r7 = r7 >>> 1;
    r9 = r9 >>> 1;
    r1 = r8 & ~r1;
    r7 = r7 & numDefine55765;
    r1 = (r1 + r7) | 0;
    r6 = r8 & ~r6;
    r7 = r9 & numDefine55765;
    r6 = (r6 + r7) | 0;
    r7 = r1 >>> numDefine2;
    r8 = r6 >>> numDefine2;
    r1 = r1 & numDefine93459;
    r7 = r7 & numDefine93459;
    r1 = (r1 + r7) | 0;
    r6 = r6 & numDefine93459;
    r7 = r8 & numDefine93459;
    r6 = (r6 + r7) | 0;
    r7 = r1 >>> numDefine4;
    r8 = r6 >>> numDefine4;
    r1 = r1 & numDefine45135;
    r7 = r7 & numDefine45135;
    r1 = (r1 + r7) | 0;
    r6 = r6 & numDefine45135;
    r7 = r8 & numDefine45135;
    r6 = (r6 + r7) | 0;
    r7 = r1 >>> numDefine8;
    r8 = r6 >>> numDefine8;
    r1 = r1 & numDefine11935;
    r7 = r7 & numDefine11935;
    r1 = (r1 + r7) | 0;
    r6 = r6 & numDefine11935;
    r7 = r8 & numDefine11935;
    r6 = (r6 + r7) | 0;
    r7 = r1 & numDefine65535;
    r1 = r1 >>> numDefine16;
    r1 = (r7 + r1) | 0;
    r7 = r6 & numDefine65535;
    r6 = r6 >>> numDefine16;
    r6 = (r7 + r6) | 0;
    r1 = (r1 + numDefine32) | 0;
    r7 = numDefine64;
    r1 = r0 !== 0 ? r6 : r1;
    r6 = numDefine63;
    r7 = (r7 - r1) | 0;
    r1 = (r6 - r1) | 0;
    if (r7 < numDefine25) {
      r3 = numDefine24;
      r3 = (r3 - r7) | 0;
      heapClassInst.heap32[g0] = r5;
      heapClassInst.heap32[g0 + 1] = r0;
      heapClassInst.heap32[g0 + numDefine2] = r3;
      ashldi3(i7);
      r5 = commonVariable.rg0;
    } else {
      if (r7 === numDefine25) {
        r0 = r0 << 1;
        r6 = r5 >>> numDefine31;
        r5 = r5 << 1;
        r0 = r0 | r6;
      } else {
        if (r7 !== numDefine26) {
          r6 = (r7 + numDefineNeg26) | 0;
          heapClassInst.heap32[g0] = r5;
          heapClassInst.heap32[g0 + 1] = r0;
          heapClassInst.heap32[g0 + numDefine2] = r6;
          lshrdi3(i7);
          r6 = commonVariable.rg0;
          r8 = commonVariable.rg1;
          r9 = numDefine90;
          r9 = (r9 - r7) | 0;
          heapClassInst.heap32[g0] = -1;
          heapClassInst.heap32[g0 + 1] = -1;
          heapClassInst.heap32[g0 + numDefine2] = r9;
          lshrdi3(i7);
          r5 = commonVariable.rg0 & r5;
          r0 = commonVariable.rg1 & r0;
          r0 = r5 | r0;

          r0 = r0 !== r4 ? 1 : 0;
          r0 = r0 & 1;
          r5 = r0 | r6;
          r0 = r8;
        }
      }
      r6 = r5 >>> numDefine2;
      r6 = r6 & 1;
      r5 = r6 | r5;
      r6 = (r5 + 1) | 0;
      r5 = uint(r6) < uint(r5) ? r3 : r4;
      r5 = r6 === 0 ? r3 : r5;
      r0 = (r0 + r5) | 0;
      r5 = r6 >>> numDefine2;
      r3 = r0 << numDefine30;
      r5 = r5 | r3;
      r3 = r5 & numDefine77216;
      if (r3 !== 0) {
        r0 = r0 >> numDefine2;
        r5 = r5 >>> 1;
        r0 = r0 << numDefine31;
        r5 = r5 | r0;
        r1 = r7;
      }
    }
    r0 = r1 << numDefine23;
    r1 = r5 & numDefine88607;
    r2 = r2 & numDefineNeg83648;
    r1 = r1 | r2;
    r0 = (r0 + numDefine53216) | 0;
    r0 = r1 | r0;
    heapClassInst.heap32[fp + -1] = r0;
    f0 = heapClassInst.heapFloat[fp + -1];
    commonVariable.fg0 = f0;
    return;
  }
}

function globalIMandreelCreateTcpSocket(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = swriteIndex.mandreelFlashTcpOnErrorIndex;
  r1 = zzl32MandreelInitTcpSocketLibrayvE47s723478567MandreelMandreelFlashTcpOnError;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  iMandreelRegisterExternalCallback(i7);
  return;
}

function mandreelFlashTcpOnConnect(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function mandreelFlashTcpReceiveCallbak(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32784;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heapU8[r0];
  repeat1: do {
    if (r2 !== 0) {
      r3 = (r0 + 1) | 0;
      r4 = 0;
      repeat3: while (true) {
        r2 = (r4 + 1) | 0;
        r5 = heapClassInst.heapU8[r3 + r4];
        r4 = r2;
        if (r5 !== 0) {
          continue repeat3;
        } else {
          break repeat1;
        }
      }
    } else {
      r2 = 0;
    }
  } while (false);
  r3 = sp + numDefineNeg32768;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  heapClassInst.heap32[g0 + numDefine3] = numDefine32768;
  r0 = zl10sASockets;
  r2 = 0;
  zn12mandreelB6410b64DecodeEPKcjPvj(i7);
  r4 = commonVariable.rg0;
  r6 = zl10sASockets;
  repeat7: while (true) {
    if (uint(r2) < uint(numDefine8)) {
      r5 = (r2 * numDefine8198) | 0;
      r5 = r5 << numDefine2;
      r5 = (r6 + r5) | 0;
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + numDefine8196];
      if (r5 !== r1) {
        r2 = (r2 + 1) | 0;
        r0 = (r0 + numDefine32792) | 0;
        continue repeat7;
      } else {
        label = numDefine9;
        break repeat7;
      }
    } else {
      label = numDefine8;
      break repeat7;
    }
  }
  if (label === numDefine8) {
    r0 = 0;
  }
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine8194];
  if (r4 > 0) {
    r5 = r4;
    repeat16: while (true) {
      r6 = (r2 + 1) | 0;
      r5 = (r5 + -1) | 0;
      r6 = r6 & numDefine32767;
      r7 = (r3 + 1) | 0;
      r3 = heapClassInst.heapU8[r3];
      heapClassInst.heap8[r0 + r2] = r3;
      r3 = r7;
      r2 = r6;
      if (!(r5 !== 0)) {
        break repeat16;
      }
    }
    r2 = r6;
  }
  heapClassInst.heap32[r1 + numDefine8194] = r2;
  r0 = heapClassInst.heap32[r1 + numDefine8192];
  r0 = (r0 + r4) | 0;
  heapClassInst.heap32[r1 + numDefine8192] = r0;
  return;
}

function globalDzn8OpenGLES12OpenGLESUtil15getCurrentErrorEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  heapClassInst.heap32[g0] = 0;
  z41StaticInitializationAndDestruction0ii(i7);
  return;
}

function znst5dequeIjSaIjEE5eraseESt15RwDequeIterIjiPjRjS0ES5(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine4];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[r0];
  r5 = heapClassInst.heap32[fp + numDefine3];
  r6 = heapClassInst.heap32[r0 + 1];
  r7 = r4 | r3;
  if (r7 !== 0) {
    r7 = r6 >> numDefine2;
    r8 = (r6 - r5) | 0;
    r9 = r5 >> numDefine2;
    r8 = r8 << numDefine3;
    r9 = heapClassInst.heap32[r9];
    r7 = heapClassInst.heap32[r7];
    r7 = (r4 - r7) | 0;
    r8 = (r8 + numDefineNeg32) | 0;
    r9 = (r9 + numDefine128) | 0;
    r9 = (r9 - r3) | 0;
    r7 = r7 >> numDefine2;
    r8 = r8 & numDefineNeg32;
    r7 = (r7 + r8) | 0;
    r8 = r9 >> numDefine2;
    r7 = (r7 + r8) | 0;
  } else {
    r7 = (r4 - r3) | 0;
    r7 = r7 >> numDefine2;
  }
  r8 = r2 >> numDefine2;
  r9 = heapClassInst.heap32[r8];
  r10 = heapClassInst.heap32[r8 + 1];
  r11 = r3 | r9;
  if (r11 !== 0) {
    r11 = (r5 - r10) | 0;
    r12 = r5 >> numDefine2;
    r13 = r10 >> numDefine2;
    r11 = r11 << numDefine3;
    r13 = heapClassInst.heap32[r13];
    r12 = heapClassInst.heap32[r12];
    r11 = (r11 + numDefineNeg32) | 0;
    r12 = (r3 - r12) | 0;
    r13 = (r13 + numDefine128) | 0;
    r13 = (r13 - r9) | 0;
    r11 = r11 & numDefineNeg32;
    r12 = r12 >> numDefine2;
    r11 = (r11 + r12) | 0;
    r12 = r13 >> numDefine2;
    r11 = (r11 + r12) | 0;
  } else {
    r11 = (r3 - r9) | 0;
    r11 = r11 >> numDefine2;
  }
  r2 = (r2 + numDefine8) | 0;
  r12 = heapClassInst.heap32[r8 + numDefine2];
  r13 = heapClassInst.heap32[r8 + numDefine3];
  r14 = r12 | r4;
  if (r14 !== 0) {
    r14 = (r13 - r6) | 0;
    r15 = r13 >> numDefine2;
    r16 = r6 >> numDefine2;
    r14 = r14 << numDefine3;
    r16 = heapClassInst.heap32[r16];
    r15 = heapClassInst.heap32[r15];
    r14 = (r14 + numDefineNeg32) | 0;
    r15 = (r12 - r15) | 0;
    r16 = (r16 + numDefine128) | 0;
    r16 = (r16 - r4) | 0;
    r14 = r14 & numDefineNeg32;
    r15 = r15 >> numDefine2;
    r14 = (r14 + r15) | 0;
    r15 = r16 >> numDefine2;
    r14 = (r14 + r15) | 0;
  } else {
    r14 = (r12 - r4) | 0;
    r14 = r14 >> numDefine2;
  }
  if (r11 >= r14) {
    r0 = (r5 + numDefine4) | 0;
    r9 = r3;
    repeat15: while (true) {
      r10 = r4 | r12;
      if (r10 !== 0) {
        r10 = r6 >> numDefine2;
        r11 = (r6 - r13) | 0;
        r14 = r13 >> numDefine2;
        r11 = r11 << numDefine3;
        r14 = heapClassInst.heap32[r14];
        r10 = heapClassInst.heap32[r10];
        r10 = (r4 - r10) | 0;
        r11 = (r11 + numDefineNeg32) | 0;
        r14 = (r14 + numDefine128) | 0;
        r14 = (r14 - r12) | 0;
        r10 = r10 >> numDefine2;
        r11 = r11 & numDefineNeg32;
        r10 = (r10 + r11) | 0;
        r11 = r14 >> numDefine2;
        r10 = (r10 + r11) | 0;
      } else {
        r10 = (r4 - r12) | 0;
        r10 = r10 >> numDefine2;
      }
      if (r10 !== 0) {
        r10 = r4 >> numDefine2;
        r11 = r9 >> numDefine2;
        r10 = heapClassInst.heap32[r10];
        r4 = (r4 + numDefine4) | 0;
        r14 = r6 >> numDefine2;
        heapClassInst.heap32[r11] = r10;
        r10 = heapClassInst.heap32[r14];
        r10 = (r10 + numDefine128) | 0;
        if (r4 === r10) {
          r6 = (r6 + numDefine4) | 0;
          r4 = heapClassInst.heap32[r14 + 1];
        }
        r10 = r0 >> numDefine2;
        r9 = (r9 + numDefine4) | 0;
        r11 = heapClassInst.heap32[r10 + -1];
        r11 = (r11 + numDefine128) | 0;
        if (!(r9 !== r11)) {
          r9 = heapClassInst.heap32[r10];
          r0 = (r0 + numDefine4) | 0;
        }
      } else {
        break repeat15;
      }
    }
    repeat27: do {
      if (!(r7 === 0)) {
        r0 = heapClassInst.heap32[r8 + numDefine2];
        while (true) {
          r0 = (r0 + numDefineNeg4) | 0;
          heapClassInst.heap32[r8 + numDefine2] = r0;
          r4 = heapClassInst.heap32[r8 + numDefine3];
          r6 = heapClassInst.heap32[r8 + 1];
          if (r6 !== r4) {
            label = numDefine45;
          } else {
            r6 = heapClassInst.heap32[r8];
            if (r6 !== r0) {
              label = numDefine45;
            } else {
              r0 = r4 >> numDefine2;
              r4 = heapClassInst.heap32[r0];
              label = numDefine47;
            }
          }
          if (label === numDefine45) {
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            if (r0 === r4) {
              label = numDefine47;
            } else {
              label = numDefine46;
            }
          }
          repeat36: do {
            if (label === numDefine47) {
              heapClassInst.heap32[g0] = r4;
              zdlPv(i7);
              r0 = heapClassInst.heap32[r8 + numDefine3];
              r4 = heapClassInst.heap32[r8 + 1];
              if (!(r4 !== r0)) {
                r4 = heapClassInst.heap32[r8];
                r6 = heapClassInst.heap32[r8 + numDefine2];
                if (!(r4 !== r6)) {
                  r0 = heapClassInst.heap32[r8 + numDefine4];
                  r0 = (r0 + numDefineNeg4) | 0;
                  heapClassInst.heap32[g0] = r0;
                  zdlPv(i7);
                  heapClassInst.heap32[r8 + numDefine2] = 0;
                  heapClassInst.heap32[r8 + numDefine3] = r2;
                  heapClassInst.heap32[r8] = 0;
                  heapClassInst.heap32[r8 + 1] = r2;
                  r0 = 0;
                  heapClassInst.heap32[r8 + numDefine4] = 0;
                  heapClassInst.heap32[r8 + numDefine5] = 0;
                  break repeat36;
                }
              }
              r4 = r0 >> numDefine2;
              r6 = (r0 + numDefineNeg4) | 0;
              heapClassInst.heap32[r4] = 0;
              heapClassInst.heap32[r8 + numDefine3] = r6;
              r0 = heapClassInst.heap32[r4 + -1];
              r0 = (r0 + numDefine128) | 0;
              heapClassInst.heap32[r8 + numDefine2] = r0;
              heapClassInst.heap32[r8 + numDefine3] = r6;
            }
          } while (false);
          r7 = (r7 + -1) | 0;
          if (r7 === 0) {
            break repeat27;
          }
        }
      }
    } while (false);
    r0 = r1 >> numDefine2;
    heapClassInst.heap32[r0] = r3;
    heapClassInst.heap32[r0 + 1] = r5;
    return;
  } else {
    repeat44: while (true) {
      r12 = r9 | r3;
      if (r12 !== 0) {
        r12 = r10 >> numDefine2;
        r13 = (r10 - r5) | 0;
        r11 = r5 >> numDefine2;
        r13 = r13 << numDefine3;
        r11 = heapClassInst.heap32[r11];
        r12 = heapClassInst.heap32[r12];
        r12 = (r9 - r12) | 0;
        r13 = (r13 + numDefineNeg32) | 0;
        r11 = (r11 + numDefine128) | 0;
        r11 = (r11 - r3) | 0;
        r12 = r12 >> numDefine2;
        r13 = r13 & numDefineNeg32;
        r12 = (r12 + r13) | 0;
        r13 = r11 >> numDefine2;
        r12 = (r12 + r13) | 0;
      } else {
        r12 = (r9 - r3) | 0;
        r12 = r12 >> numDefine2;
      }
      if (r12 !== 0) {
        r12 = r6 >> numDefine2;
        r13 = heapClassInst.heap32[r12];
        if (r4 === r13) {
          r4 = heapClassInst.heap32[r12 + -1];
          r6 = (r6 + numDefineNeg4) | 0;
          r4 = (r4 + numDefine128) | 0;
        }
        r12 = r5 >> numDefine2;
        r4 = (r4 + numDefineNeg4) | 0;
        r13 = heapClassInst.heap32[r12];
        if (r3 === r13) {
          r3 = heapClassInst.heap32[r12 + -1];
          r5 = (r5 + numDefineNeg4) | 0;
          r3 = (r3 + numDefine128) | 0;
        }
        r12 = r3 >> numDefine2;
        r3 = (r3 + numDefineNeg4) | 0;
        r13 = r4 >> numDefine2;
        r12 = heapClassInst.heap32[r12 + -1];
        heapClassInst.heap32[r13] = r12;
      } else {
        break repeat44;
      }
    }
    repeat58: do {
      if (!(r7 === 0)) {
        r3 = heapClassInst.heap32[r8];
        while (true) {
          r3 = (r3 + numDefine4) | 0;
          heapClassInst.heap32[r8] = r3;
          r4 = heapClassInst.heap32[r8 + 1];
          r5 = heapClassInst.heap32[r8 + numDefine3];
          if (r4 !== r5) {
            label = numDefine24;
          } else {
            r5 = r2 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            if (r3 !== r5) {
              label = numDefine24;
            } else {
              r3 = r4 >> numDefine2;
              r4 = heapClassInst.heap32[r3];
              label = numDefine26;
            }
          }
          if (label === numDefine24) {
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            r5 = (r4 + numDefine128) | 0;
            if (r3 === r5) {
              label = numDefine26;
            } else {
              label = numDefine25;
            }
          }
          repeat67: do {
            if (label === numDefine26) {
              heapClassInst.heap32[g0] = r4;
              zdlPv(i7);
              r3 = heapClassInst.heap32[r8 + 1];
              r4 = heapClassInst.heap32[r8 + numDefine3];
              if (!(r3 !== r4)) {
                r4 = heapClassInst.heap32[r8];
                r5 = heapClassInst.heap32[r8 + numDefine2];
                if (!(r4 !== r5)) {
                  r3 = heapClassInst.heap32[r8 + numDefine4];
                  r3 = (r3 + numDefineNeg4) | 0;
                  heapClassInst.heap32[g0] = r3;
                  zdlPv(i7);
                  heapClassInst.heap32[r8 + numDefine2] = 0;
                  heapClassInst.heap32[r8 + numDefine3] = r2;
                  heapClassInst.heap32[r8] = 0;
                  heapClassInst.heap32[r8 + 1] = r2;
                  r3 = 0;
                  heapClassInst.heap32[r8 + numDefine4] = 0;
                  heapClassInst.heap32[r8 + numDefine5] = 0;
                  break repeat67;
                }
              }
              r4 = r3 >> numDefine2;
              r5 = (r3 + numDefine4) | 0;
              heapClassInst.heap32[r4] = 0;
              heapClassInst.heap32[r8 + 1] = r5;
              r3 = heapClassInst.heap32[r4 + 1];
              heapClassInst.heap32[r8] = r3;
              heapClassInst.heap32[r8 + 1] = r5;
            }
          } while (false);
          r7 = (r7 + -1) | 0;
          if (r7 === 0) {
            break repeat58;
          }
        }
      }
    } while (false);
    r1 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r0];
    heapClassInst.heap32[r1] = r2;
    r2 = heapClassInst.heap32[r0 + 1];
    heapClassInst.heap32[r1 + 1] = r2;
    return;
  }
}

function z41StaticInitializationAndDestruction0ii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg80;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (r0 === 0) {
    r0 = zl13sFifoErrors;
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine2];
    r3 = sp + numDefineNeg24;
    heapClassInst.heap32[fp + numDefineNeg6] = r2;
    r2 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r1 + numDefine3];
    heapClassInst.heap32[r2 + 1] = r4;
    r2 = heapClassInst.heap32[r1];
    r1 = heapClassInst.heap32[r1 + 1];
    r4 = sp + numDefineNeg32;
  } else {
    if (r0 !== 1) {
      return;
    } else {
      r0 = sp + numDefineNeg56;
      r1 = r0 >> numDefine2;
      r2 = (r0 + numDefine8) | 0;
      heapClassInst.heap32[r1 + numDefine2] = 0;
      heapClassInst.heap32[r1 + numDefine3] = r2;
      heapClassInst.heap32[fp + numDefineNeg14] = 0;
      heapClassInst.heap32[r1 + 1] = r2;
      r2 = zl13sFifoErrors;
      heapClassInst.heap32[r1 + numDefine4] = 0;
      r3 = r2 >> numDefine2;
      heapClassInst.heap32[r1 + numDefine5] = 0;
      r4 = (r2 + numDefine8) | 0;
      heapClassInst.heap32[r3 + numDefine2] = 0;
      heapClassInst.heap32[r3 + numDefine3] = r4;
      heapClassInst.heap32[r3] = 0;
      heapClassInst.heap32[r3 + 1] = r4;
      r5 = 0;
      heapClassInst.heap32[r3 + numDefine4] = 0;
      heapClassInst.heap32[r3 + numDefine5] = 0;
      r6 = r4;
      r7 = r5;
      repeat7: while (true) {
        if (r7 !== 0) {
          r8 = (r2 + numDefine8) | 0;
          r8 = (r8 - r6) | 0;
          r9 = r6 >> numDefine2;
          r8 = r8 << numDefine3;
          r9 = heapClassInst.heap32[r9];
          r10 = 0;
          r11 = heapClassInst.heap32[r3 + numDefine2];
          r10 = (r10 - r11) | 0;
          r8 = (r8 + numDefineNeg32) | 0;
          r9 = (r9 + numDefine128) | 0;
          r9 = (r9 - r7) | 0;
          r10 = r10 >> numDefine2;
          r8 = r8 & numDefineNeg32;
          r8 = (r10 + r8) | 0;
          r9 = r9 >> numDefine2;
          r8 = (r8 + r9) | 0;
        } else {
          r8 = 0;
          r8 = (r8 - r7) | 0;
          r8 = r8 >> numDefine2;
        }
        if (r8 !== 0) {
          r8 = r4 >> numDefine2;
          r9 = heapClassInst.heap32[r8];
          if (r5 === r9) {
            r5 = heapClassInst.heap32[r8 + -1];
            r4 = (r4 + numDefineNeg4) | 0;
            r5 = (r5 + numDefine128) | 0;
          }
          r8 = r6 >> numDefine2;
          r5 = (r5 + numDefineNeg4) | 0;
          r9 = heapClassInst.heap32[r8];
          if (r7 === r9) {
            r7 = heapClassInst.heap32[r8 + -1];
            r6 = (r6 + numDefineNeg4) | 0;
            r7 = (r7 + numDefine128) | 0;
          }
          r8 = r7 >> numDefine2;
          r7 = (r7 + numDefineNeg4) | 0;
          r9 = r5 >> numDefine2;
          r8 = heapClassInst.heap32[r8 + -1];
          heapClassInst.heap32[r9] = r8;
        } else {
          break repeat7;
        }
      }
      r2 = heapClassInst.heap32[r1 + numDefine2];
      r3 = sp + numDefineNeg8;
      heapClassInst.heap32[fp + numDefineNeg2] = r2;
      r2 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r1 + numDefine3];
      heapClassInst.heap32[r2 + 1] = r4;
      r2 = heapClassInst.heap32[fp + numDefineNeg14];
      r1 = heapClassInst.heap32[r1 + 1];
      r4 = sp + numDefineNeg16;
    }
  }
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r1;
  heapClassInst.heap32[g0 + numDefine4] = r3;
  znst5dequeIjSaIjEE5eraseESt15RwDequeIterIjiPjRjS0ES5(i7);
  return;
}

function globalIzn5myGl14glAttachShaderEjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = zn5myGlL9mContextE;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine62] = 0;
  heapClassInst.heap32[r1 + numDefine63] = 0;
  heapClassInst.heap32[r1 + numDefine64] = 0;
  heapClassInst.heap32[r1 + numDefine65] = 0;
  heapClassInst.heap32[r1 + numDefine66] = 0;
  heapClassInst.heap32[r1 + numDefine67] = 0;
  heapClassInst.heap32[r1 + numDefine78] = 0;
  heapClassInst.heap32[r1 + numDefine79] = 0;
  heapClassInst.heap32[r1 + numDefine74] = 0;
  heapClassInst.heap32[r1 + numDefine77] = 0;
  heapClassInst.heap32[r1 + numDefine76] = 0;
  heapClassInst.heap32[r1 + numDefine75] = 0;
  zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE11CGetLinkEv(i7);
  r2 = commonVariable.rg0;
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine78] = r2;
  heapClassInst.heap32[r3 + 1] = 0;
  heapClassInst.heap32[r3 + numDefine3] = r2;
  heapClassInst.heap32[r3 + numDefine2] = r2;
  heapClassInst.heap32[r1] = 0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  heapClassInst.heap32[r1 + numDefine61] = 0;
  heapClassInst.heap32[r1 + numDefine4] = 0;
  heapClassInst.heap32[r1 + numDefine68] = 0;
  heapClassInst.heap32[r1 + numDefine69] = 0;
  r2 = zl26sMandreelInternalHeight;
  r3 = zl25sMandreelInternalWidth;
  heapClassInst.heap32[r1 + 1] = 0;
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine2] = 1;
  r3 = r3 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[r1 + numDefine70] = 0;
  heapClassInst.heap32[r1 + numDefine71] = 0;
  r4 = numDefine224;
  heapClassInst.heap32[r1 + numDefine72] = r3;
  heapClassInst.heap32[r1 + numDefine73] = r2;
  r2 = 0;
  repeat2: while (true) {
    r1 = (r4 + -1) | 0;
    r4 = (r0 - r4) | 0;
    heapClassInst.heap8[r4 + numDefine244] = r2;
    r4 = r1;
    if (r1 !== 0) {
      continue repeat2;
    } else {
      break repeat2;
    }
  }
  return;
}

function globalDzn5myGl14glAttachShaderEjj(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = zn5myGlL9mContextE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine78];
  repeat1: do {
    if (!(r1 === 0)) {
      r2 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r0 + numDefine79];
      if (r3 !== 0) {
        r1 = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[g0] = r1;
        zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE8CEraseEPNS17RwRbTreeNodeISBS6JS8EE(i7);
        r1 = heapClassInst.heap32[r0 + numDefine78];
        r2 = r1 >> numDefine2;
        heapClassInst.heap32[r2 + 1] = 0;
        heapClassInst.heap32[r2 + numDefine3] = r1;
        heapClassInst.heap32[r2 + numDefine2] = r1;
        heapClassInst.heap32[r0 + numDefine79] = 0;
      } else {
        r2 = heapClassInst.heap32[r2 + numDefine2];
        if (!(r2 === r1)) {
          repeat6: while (true) {
            r3 = r2;
            r4 = r3 >> numDefine2;
            r2 = heapClassInst.heap32[r4 + numDefine3];
            repeat8: do {
              if (r2 !== 0) {
                r4 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r4 + numDefine2];
                if (r4 === 0) {
                  break repeat8;
                } else {
                  label = numDefine8;
                  repeat10: while (true) {
                    r2 = r4;
                    r4 = r2 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + numDefine2];
                    if (r4 !== 0) {
                      continue repeat10;
                    } else {
                      break repeat8;
                    }
                  }
                }
              } else {
                r4 = heapClassInst.heap32[r4 + 1];
                r2 = r4 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine3];
                if (r3 === r2) {
                  repeat14: while (true) {
                    r2 = r4;
                    r5 = r2 >> numDefine2;
                    r4 = heapClassInst.heap32[r5 + 1];
                    r6 = r4 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine3];
                    if (!(r2 === r6)) {
                      break repeat14;
                    }
                  }
                  r5 = heapClassInst.heap32[r5 + numDefine3];
                } else {
                  r5 = 0;
                  r2 = r3;
                }
                if (r5 !== r4) {
                  r2 = r4;
                }
              }
            } while (false);
            r4 = sp + numDefineNeg8;
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r3;
            zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE5eraseENS14RwTreeIterIS6IPS6RS6NS17RwRbTreeNodeISBS6JS8EEEE(i7);
            if (!(r2 !== r1)) {
              break repeat6;
            }
          }
          r1 = heapClassInst.heap32[r0 + numDefine78];
        }
      }
      r2 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r0 + numDefine75];
      heapClassInst.heap32[r2 + numDefine3] = r3;
      heapClassInst.heap32[r0 + numDefine75] = r1;
      r1 = heapClassInst.heap32[r0 + numDefine74];
      if (!(r1 === 0)) {
        label = numDefine16;
        repeat23: while (true) {
          r2 = r1 >> numDefine2;
          r3 = heapClassInst.heap32[r2];
          heapClassInst.heap32[r0 + numDefine74] = r3;
          r2 = heapClassInst.heap32[r2 + numDefine2];
          heapClassInst.heap32[g0] = r2;
          zdlPv(i7);
          heapClassInst.heap32[g0] = r1;
          zdlPv(i7);
          r1 = heapClassInst.heap32[r0 + numDefine74];
          if (r1 !== 0) {
            continue repeat23;
          } else {
            break repeat1;
          }
        }
      }
    }
  } while (false);
  r1 = heapClassInst.heap32[r0 + numDefine65];
  r2 = heapClassInst.heap32[r0 + numDefine66];
  r3 = (r2 - r1) | 0;
  r3 = r3 >> numDefine5;
  if (r3 !== 0) {
    r1 = (r2 + numDefineNeg32) | 0;
    heapClassInst.heap32[r0 + numDefine66] = r1;
    r1 = (r2 + numDefineNeg28) | 0;
    heapClassInst.heap32[g0] = r1;
    zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EED2Ev(i7);
    repeat31: do {
      if (!(r3 === 1)) {
        r1 = (r3 + -1) | 0;
        while (true) {
          r2 = heapClassInst.heap32[r0 + numDefine66];
          r3 = (r2 + numDefineNeg32) | 0;
          heapClassInst.heap32[r0 + numDefine66] = r3;
          r2 = (r2 + numDefineNeg28) | 0;
          heapClassInst.heap32[g0] = r2;
          zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EED2Ev(i7);
          r1 = (r1 + -1) | 0;
          if (!(r1 !== 0)) {
            break repeat31;
          }
        }
      }
    } while (false);
    r1 = heapClassInst.heap32[r0 + numDefine65];
  }
  heapClassInst.heap32[g0] = r1;
  zdlPv(i7);
  r1 = heapClassInst.heap32[r0 + numDefine63];
  r2 = heapClassInst.heap32[r0 + numDefine62];
  r3 = (r1 - r2) | 0;
  r4 = (r3 + numDefine11) | 0;
  if (!(uint(r4) < uint(numDefine23))) {
    r3 = (r3 / numDefineNeg12) | 0;
    r3 = (r3 * numDefine12) | 0;
    r1 = (r1 + r3) | 0;
    heapClassInst.heap32[r0 + numDefine63] = r1;
  }
  heapClassInst.heap32[g0] = r2;
  zdlPv(i7);
  return;
}

function zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE8CEraseEPNS17RwRbTreeNodeISBS6JS8EE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (!(r0 === 0)) {
    repeat2: while (true) {
      r1 = r0 >> numDefine2;
      r2 = heapClassInst.heap32[r1 + numDefine3];
      heapClassInst.heap32[g0] = r2;
      r2 = zn5myGlL9mContextE;
      zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE8CEraseEPNS17RwRbTreeNodeISBS6JS8EE(i7);
      r2 = r2 >> numDefine2;
      r3 = heapClassInst.heap32[r1 + numDefine2];
      r4 = heapClassInst.heap32[r2 + numDefine75];
      heapClassInst.heap32[r1 + numDefine3] = r4;
      heapClassInst.heap32[r2 + numDefine75] = r0;
      r0 = r3;
      if (r3 !== 0) {
        continue repeat2;
      } else {
        break repeat2;
      }
    }
  }
  return;
}

function zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EE8CEraseEPNS17RwRbTreeNodeIS8S3SsS5EE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  if (!(r0 === 0)) {
    r1 = heapClassInst.heap32[fp];
    repeat3: while (true) {
      r2 = r0;
      r3 = r2 >> numDefine2;
      r0 = heapClassInst.heap32[r3 + numDefine3];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EE8CEraseEPNS17RwRbTreeNodeIS8S3SsS5EE(i7);
      r4 = r1 >> numDefine2;
      r0 = heapClassInst.heap32[r3 + numDefine2];
      r5 = heapClassInst.heap32[r4 + 1];
      heapClassInst.heap32[r3 + numDefine3] = r5;
      r5 = heapClassInst.heap32[r3 + numDefine4];
      r5 = (r5 + numDefineNeg12) | 0;
      r6 = znss11CNullRefE;
      if (!(r5 === r6)) {
        r5 = r5 >> numDefine2;
        r6 = heapClassInst.heap32[r5];
        r7 = (r6 + -1) | 0;
        heapClassInst.heap32[r5] = r7;
        if (!(r6 > 0)) {
          r5 = heapClassInst.heap32[r3 + numDefine4];
          r5 = (r5 + numDefineNeg12) | 0;
          heapClassInst.heap32[g0] = r5;
          zdlPv(i7);
        }
      }
      heapClassInst.heap32[r3 + numDefine4] = 0;
      heapClassInst.heap32[r4 + 1] = r2;
      if (r0 !== 0) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EE5eraseENS14RwTreeIterIS3IPS3RS3NS17RwRbTreeNodeIS8S3SsS5EEEESF(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r4 = heapClassInst.heap32[r0];
  r5 = heapClassInst.heap32[fp];
  r6 = heapClassInst.heap32[fp + numDefine3];
  r7 = r3 >> numDefine2;
  r8 = heapClassInst.heap32[r7 + numDefine2];
  if (!(r4 !== r8)) {
    if (!(r3 !== r6)) {
      r8 = heapClassInst.heap32[r2 + numDefine5];
      if (r8 !== 0) {
        r0 = heapClassInst.heap32[r7 + 1];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r0;
        zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EE8CEraseEPNS17RwRbTreeNodeIS8S3SsS5EE(i7);
        r0 = heapClassInst.heap32[r2 + numDefine4];
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0 + 1] = 0;
        r0 = heapClassInst.heap32[r2 + numDefine4];
        r1 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = r0;
        heapClassInst.heap32[r1 + numDefine2] = r0;
        heapClassInst.heap32[r2 + numDefine5] = 0;
        r0 = r5 >> numDefine2;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[r0] = r1;
        return;
      }
    }
  }
  r1 = r5 >> numDefine2;
  heapClassInst.heap32[r1] = r3;
  if (!(r4 === r6)) {
    repeat7: while (true) {
      r3 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r3 + numDefine3];
      if (r5 !== 0) {
        r7 = r5 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + numDefine2];
        if (!(r7 === 0)) {
          repeat12: while (true) {
            r5 = r7;
            r7 = r5 >> numDefine2;
            r7 = heapClassInst.heap32[r7 + numDefine2];
            if (!(r7 !== 0)) {
              break repeat12;
            }
          }
        }
        heapClassInst.heap32[r0] = r5;
      } else {
        r7 = heapClassInst.heap32[r3 + 1];
        r5 = r7 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine3];
        if (r4 === r5) {
          repeat17: while (true) {
            r5 = r7;
            r8 = r5 >> numDefine2;
            r7 = heapClassInst.heap32[r8 + 1];
            r9 = r7 >> numDefine2;
            r9 = heapClassInst.heap32[r9 + numDefine3];
            if (!(r5 === r9)) {
              break repeat17;
            }
          }
          heapClassInst.heap32[r0] = r5;
          r8 = heapClassInst.heap32[r8 + numDefine3];
        } else {
          r8 = 0;
          r5 = r4;
        }
        if (r8 !== r7) {
          heapClassInst.heap32[r0] = r7;
          r5 = r7;
        }
      }
      r7 = heapClassInst.heap32[r2 + numDefine4];
      if (r4 !== r7) {
        r9 = heapClassInst.heap32[r3 + numDefine3];
        repeat26: do {
          if (r9 !== 0) {
            r8 = r9 >> numDefine2;
            r10 = heapClassInst.heap32[r8 + numDefine2];
            if (r10 === 0) {
              r8 = r9;
            } else {
              repeat30: while (true) {
                r8 = r10;
                r10 = r8 >> numDefine2;
                r10 = heapClassInst.heap32[r10 + numDefine2];
                if (r10 !== 0) {
                  continue repeat30;
                } else {
                  break repeat26;
                }
              }
            }
          } else {
            r8 = heapClassInst.heap32[r3 + 1];
            r10 = r8 >> numDefine2;
            r10 = heapClassInst.heap32[r10 + numDefine3];
            if (r4 === r10) {
              repeat34: while (true) {
                r11 = r8;
                r10 = r11 >> numDefine2;
                r8 = heapClassInst.heap32[r10 + 1];
                r12 = r8 >> numDefine2;
                r12 = heapClassInst.heap32[r12 + numDefine3];
                if (!(r11 === r12)) {
                  break repeat34;
                }
              }
              r10 = heapClassInst.heap32[r10 + numDefine3];
            } else {
              r10 = 0;
              r11 = r4;
            }
            if (r10 === r8) {
              r8 = r11;
            }
          }
        } while (false);
        r10 = heapClassInst.heap32[r3 + numDefine2];
        if (r10 !== 0) {
          if (r9 !== 0) {
            r11 = r9 >> numDefine2;
            r12 = heapClassInst.heap32[r11 + numDefine2];
            repeat45: do {
              if (r12 === 0) {
                r11 = r9;
              } else {
                while (true) {
                  r11 = r12;
                  r12 = r11 >> numDefine2;
                  r12 = heapClassInst.heap32[r12 + numDefine2];
                  if (!(r12 !== 0)) {
                    break repeat45;
                  }
                }
              }
            } while (false);
            r13 = r11 >> numDefine2;
            r9 = heapClassInst.heap32[r13 + numDefine3];
            if (r11 !== r4) {
              r7 = r10 >> numDefine2;
              heapClassInst.heap32[r7 + 1] = r11;
              r7 = heapClassInst.heap32[r3 + numDefine2];
              heapClassInst.heap32[r13 + numDefine2] = r7;
              r7 = heapClassInst.heap32[r3 + numDefine3];
              if (r7 !== r11) {
                r12 = heapClassInst.heap32[r13 + 1];
                if (r9 !== 0) {
                  r7 = r9 >> numDefine2;
                  heapClassInst.heap32[r7 + 1] = r12;
                  r7 = heapClassInst.heap32[r13 + 1];
                } else {
                  r7 = r12;
                }
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7 + numDefine2] = r9;
                r7 = heapClassInst.heap32[r3 + numDefine3];
                heapClassInst.heap32[r13 + numDefine3] = r7;
                r7 = heapClassInst.heap32[r3 + numDefine3];
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7 + 1] = r11;
              } else {
                r12 = r11;
              }
              r7 = heapClassInst.heap32[r2 + numDefine4];
              r7 = r7 >> numDefine2;
              r10 = heapClassInst.heap32[r7 + 1];
              if (r10 !== r4) {
                r7 = heapClassInst.heap32[r3 + 1];
                r10 = r7 >> numDefine2;
                r10 = heapClassInst.heap32[r10 + numDefine2];

                r10 = r10 !== r4 ? 1 : 0;
                r10 = r10 & 1;
                r10 = r10 << numDefine2;
                r7 = (r7 + r10) | 0;
                r7 = (r7 + numDefine8) | 0;
                r10 = (r4 + numDefine4) | 0;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7] = r11;
              } else {
                r10 = (r4 + numDefine4) | 0;
                heapClassInst.heap32[r7 + 1] = r11;
              }
              r7 = r10 >> numDefine2;
              r7 = heapClassInst.heap32[r7];
              heapClassInst.heap32[r13 + 1] = r7;
              r7 = heapClassInst.heap32[r13];
              r11 = heapClassInst.heap32[r3];
              heapClassInst.heap32[r13] = r11;
              heapClassInst.heap32[r3] = r7;
              label = numDefine66;
            } else {
              label = numDefine45;
            }
          } else {
            r12 = heapClassInst.heap32[r3 + 1];
            r11 = r4;
            r9 = r10;
            label = numDefine47;
          }
        } else {
          r11 = r4;
          label = numDefine45;
        }
        if (label === numDefine45) {
          r12 = r11 >> numDefine2;
          r12 = heapClassInst.heap32[r12 + 1];
          if (r9 === 0) {
            r9 = 0;
            label = numDefine48;
          } else {
            label = numDefine47;
          }
        }
        if (label === numDefine47) {
          r7 = r9 >> numDefine2;
          heapClassInst.heap32[r7 + 1] = r12;
          r7 = heapClassInst.heap32[r2 + numDefine4];
          label = numDefine48;
        }
        if (label === numDefine48) {
          r7 = r7 >> numDefine2;
          r10 = heapClassInst.heap32[r7 + 1];
          if (r10 !== r4) {
            r7 = heapClassInst.heap32[r3 + 1];
            r10 = r7 >> numDefine2;
            r10 = heapClassInst.heap32[r10 + numDefine2];

            r10 = r10 !== r4 ? 1 : 0;
            r10 = r10 & 1;
            r10 = r10 << numDefine2;
            r7 = (r7 + r10) | 0;
            r7 = (r7 + numDefine8) | 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7] = r9;
          } else {
            heapClassInst.heap32[r7 + 1] = r9;
          }
          r7 = heapClassInst.heap32[r2 + numDefine4];
          r7 = r7 >> numDefine2;
          r10 = heapClassInst.heap32[r7 + numDefine2];
          if (!(r10 !== r4)) {
            r10 = heapClassInst.heap32[r3 + numDefine3];
            if (r10 !== 0) {
              r10 = r9 >> numDefine2;
              r10 = heapClassInst.heap32[r10 + numDefine2];
              repeat80: do {
                if (r10 === 0) {
                  r13 = r9;
                } else {
                  while (true) {
                    r13 = r10;
                    r10 = r13 >> numDefine2;
                    r10 = heapClassInst.heap32[r10 + numDefine2];
                    if (!(r10 !== 0)) {
                      break repeat80;
                    }
                  }
                }
              } while (false);
              heapClassInst.heap32[r7 + numDefine2] = r13;
            } else {
              r10 = heapClassInst.heap32[r3 + 1];
              heapClassInst.heap32[r7 + numDefine2] = r10;
            }
          }
          r7 = heapClassInst.heap32[r2 + numDefine4];
          r7 = r7 >> numDefine2;
          r10 = heapClassInst.heap32[r7 + numDefine3];
          if (r10 === r4) {
            r4 = heapClassInst.heap32[r3 + numDefine2];
            if (r4 !== 0) {
              r4 = r9 >> numDefine2;
              r4 = heapClassInst.heap32[r4 + numDefine3];
              repeat91: do {
                if (r4 === 0) {
                  r3 = r9;
                } else {
                  while (true) {
                    r3 = r4;
                    r4 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + numDefine3];
                    if (!(r4 !== 0)) {
                      break repeat91;
                    }
                  }
                }
              } while (false);
              heapClassInst.heap32[r7 + numDefine3] = r3;
              r4 = r11;
            } else {
              r4 = heapClassInst.heap32[r3 + 1];
              heapClassInst.heap32[r7 + numDefine3] = r4;
              r4 = r11;
            }
          } else {
            r4 = r11;
          }
        }
        r3 = r4 >> numDefine2;
        r7 = heapClassInst.heap32[r3];
        repeat99: do {
          if (!(r7 === 0)) {
            repeat100: while (true) {
              r7 = heapClassInst.heap32[r2 + numDefine4];
              r7 = r7 >> numDefine2;
              r7 = heapClassInst.heap32[r7 + 1];
              if (r7 === r9) {
                label = numDefine140;
                break repeat100;
              } else {
                if (!(r9 === 0)) {
                  r7 = r9 >> numDefine2;
                  r7 = heapClassInst.heap32[r7];
                  if (!(r7 === 1)) {
                    label = numDefine141;
                    break repeat100;
                  }
                }
                r7 = r12 >> numDefine2;
                r10 = heapClassInst.heap32[r7 + numDefine2];
                if (r10 !== r9) {
                  r11 = r10 >> numDefine2;
                  r13 = heapClassInst.heap32[r11];
                  if (r13 === 0) {
                    heapClassInst.heap32[r11] = 1;
                    heapClassInst.heap32[r7] = 0;
                    r10 = heapClassInst.heap32[r7 + numDefine2];
                    r11 = r10 >> numDefine2;
                    r13 = heapClassInst.heap32[r11 + numDefine3];
                    heapClassInst.heap32[r7 + numDefine2] = r13;
                    r13 = heapClassInst.heap32[r11 + numDefine3];
                    if (!(r13 === 0)) {
                      r13 = r13 >> numDefine2;
                      heapClassInst.heap32[r13 + 1] = r12;
                    }
                    r13 = heapClassInst.heap32[r7 + 1];
                    heapClassInst.heap32[r11 + 1] = r13;
                    r13 = heapClassInst.heap32[r2 + numDefine4];
                    r13 = r13 >> numDefine2;
                    r14 = heapClassInst.heap32[r13 + 1];
                    if (r14 !== r12) {
                      r13 = heapClassInst.heap32[r7 + 1];
                      r13 = r13 >> numDefine2;
                      r14 = heapClassInst.heap32[r13 + numDefine3];
                      if (r14 !== r12) {
                        heapClassInst.heap32[r13 + numDefine2] = r10;
                      } else {
                        heapClassInst.heap32[r13 + numDefine3] = r10;
                      }
                    } else {
                      heapClassInst.heap32[r13 + 1] = r10;
                    }
                    heapClassInst.heap32[r11 + numDefine3] = r12;
                    heapClassInst.heap32[r7 + 1] = r10;
                    r10 = heapClassInst.heap32[r7 + numDefine2];
                  }
                  r11 = r10 >> numDefine2;
                  r13 = heapClassInst.heap32[r11 + numDefine3];
                  if (!(r13 === 0)) {
                    r13 = r13 >> numDefine2;
                    r14 = heapClassInst.heap32[r13];
                    if (r14 !== 1) {
                      label = numDefine117;
                      break repeat100;
                    }
                  }
                  r13 = heapClassInst.heap32[r11 + numDefine2];
                  if (!(r13 === 0)) {
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    if (!(r13 === 1)) {
                      label = numDefine127;
                      break repeat100;
                    }
                  }
                  heapClassInst.heap32[r11] = 0;
                } else {
                  r10 = heapClassInst.heap32[r7 + numDefine3];
                  r11 = r10 >> numDefine2;
                  r13 = heapClassInst.heap32[r11];
                  if (r13 === 0) {
                    heapClassInst.heap32[r11] = 1;
                    heapClassInst.heap32[r7] = 0;
                    r10 = heapClassInst.heap32[r7 + numDefine3];
                    r11 = r10 >> numDefine2;
                    r13 = heapClassInst.heap32[r11 + numDefine2];
                    heapClassInst.heap32[r7 + numDefine3] = r13;
                    r13 = heapClassInst.heap32[r11 + numDefine2];
                    if (!(r13 === 0)) {
                      r13 = r13 >> numDefine2;
                      heapClassInst.heap32[r13 + 1] = r12;
                    }
                    r13 = heapClassInst.heap32[r7 + 1];
                    heapClassInst.heap32[r11 + 1] = r13;
                    r13 = heapClassInst.heap32[r2 + numDefine4];
                    r13 = r13 >> numDefine2;
                    r14 = heapClassInst.heap32[r13 + 1];
                    if (r14 !== r12) {
                      r13 = heapClassInst.heap32[r7 + 1];
                      r13 = r13 >> numDefine2;
                      r14 = heapClassInst.heap32[r13 + numDefine2];
                      if (r14 !== r12) {
                        heapClassInst.heap32[r13 + numDefine3] = r10;
                      } else {
                        heapClassInst.heap32[r13 + numDefine2] = r10;
                      }
                    } else {
                      heapClassInst.heap32[r13 + 1] = r10;
                    }
                    heapClassInst.heap32[r11 + numDefine2] = r12;
                    heapClassInst.heap32[r7 + 1] = r10;
                    r10 = heapClassInst.heap32[r7 + numDefine3];
                  }
                  r11 = r10 >> numDefine2;
                  r13 = heapClassInst.heap32[r11 + numDefine2];
                  if (!(r13 === 0)) {
                    r13 = r13 >> numDefine2;
                    r14 = heapClassInst.heap32[r13];
                    if (r14 !== 1) {
                      label = numDefine83;
                      break repeat100;
                    }
                  }
                  r13 = heapClassInst.heap32[r11 + numDefine3];
                  if (!(r13 === 0)) {
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    if (!(r13 === 1)) {
                      label = numDefine93;
                      break repeat100;
                    }
                  }
                  heapClassInst.heap32[r11] = 0;
                }
                r10 = heapClassInst.heap32[r7 + 1];
                r9 = r12;
                r12 = r10;
              }
            }
            repeat148: do {
              switch (label) {
                case numDefine117:
                  r14 = heapClassInst.heap32[r11 + numDefine2];
                  if (!(r14 === 0)) {
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    if (r14 !== 1) {
                      label = numDefine127;
                      break repeat148;
                    }
                  }
                  heapClassInst.heap32[r13] = 1;
                  r13 = heapClassInst.heap32[r11 + numDefine3];
                  r14 = r13 >> numDefine2;
                  heapClassInst.heap32[r11] = 0;
                  r15 = heapClassInst.heap32[r14 + numDefine2];
                  heapClassInst.heap32[r11 + numDefine3] = r15;
                  r15 = heapClassInst.heap32[r14 + numDefine2];
                  if (!(r15 === 0)) {
                    r15 = r15 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = r10;
                  }
                  r15 = heapClassInst.heap32[r11 + 1];
                  heapClassInst.heap32[r14 + 1] = r15;
                  r15 = heapClassInst.heap32[r2 + numDefine4];
                  r15 = r15 >> numDefine2;
                  r16 = heapClassInst.heap32[r15 + 1];
                  if (r16 !== r10) {
                    r15 = heapClassInst.heap32[r11 + 1];
                    r15 = r15 >> numDefine2;
                    r16 = heapClassInst.heap32[r15 + numDefine2];
                    if (r16 !== r10) {
                      heapClassInst.heap32[r15 + numDefine3] = r13;
                    } else {
                      heapClassInst.heap32[r15 + numDefine2] = r13;
                    }
                  } else {
                    heapClassInst.heap32[r15 + 1] = r13;
                  }
                  heapClassInst.heap32[r14 + numDefine2] = r10;
                  heapClassInst.heap32[r11 + 1] = r13;
                  r10 = heapClassInst.heap32[r7 + numDefine2];
                  label = numDefine127;
                  break repeat148;
                case numDefine83:
                  r14 = heapClassInst.heap32[r11 + numDefine3];
                  if (!(r14 === 0)) {
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    if (r14 !== 1) {
                      label = numDefine93;
                      break repeat148;
                    }
                  }
                  heapClassInst.heap32[r13] = 1;
                  r13 = heapClassInst.heap32[r11 + numDefine2];
                  r14 = r13 >> numDefine2;
                  heapClassInst.heap32[r11] = 0;
                  r15 = heapClassInst.heap32[r14 + numDefine3];
                  heapClassInst.heap32[r11 + numDefine2] = r15;
                  r15 = heapClassInst.heap32[r14 + numDefine3];
                  if (!(r15 === 0)) {
                    r15 = r15 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = r10;
                  }
                  r15 = heapClassInst.heap32[r11 + 1];
                  heapClassInst.heap32[r14 + 1] = r15;
                  r15 = heapClassInst.heap32[r2 + numDefine4];
                  r15 = r15 >> numDefine2;
                  r16 = heapClassInst.heap32[r15 + 1];
                  if (r16 !== r10) {
                    r15 = heapClassInst.heap32[r11 + 1];
                    r15 = r15 >> numDefine2;
                    r16 = heapClassInst.heap32[r15 + numDefine3];
                    if (r16 !== r10) {
                      heapClassInst.heap32[r15 + numDefine2] = r13;
                    } else {
                      heapClassInst.heap32[r15 + numDefine3] = r13;
                    }
                  } else {
                    heapClassInst.heap32[r15 + 1] = r13;
                  }
                  heapClassInst.heap32[r14 + numDefine3] = r10;
                  heapClassInst.heap32[r11 + 1] = r13;
                  r10 = heapClassInst.heap32[r7 + numDefine3];
                  label = numDefine93;
                  break;
                default:
                  break;
              }
            } while (false);
            repeat177: do {
              switch (label) {
                case numDefine127:
                  r10 = r10 >> numDefine2;
                  r11 = heapClassInst.heap32[r7];
                  heapClassInst.heap32[r10] = r11;
                  heapClassInst.heap32[r7] = 1;
                  r10 = heapClassInst.heap32[r10 + numDefine2];
                  if (!(r10 === 0)) {
                    r10 = r10 >> numDefine2;
                    heapClassInst.heap32[r10] = 1;
                  }
                  r10 = heapClassInst.heap32[r7 + numDefine2];
                  r11 = r10 >> numDefine2;
                  r13 = heapClassInst.heap32[r11 + numDefine3];
                  heapClassInst.heap32[r7 + numDefine2] = r13;
                  r13 = heapClassInst.heap32[r11 + numDefine3];
                  if (!(r13 === 0)) {
                    r13 = r13 >> numDefine2;
                    heapClassInst.heap32[r13 + 1] = r12;
                  }
                  r13 = heapClassInst.heap32[r7 + 1];
                  heapClassInst.heap32[r11 + 1] = r13;
                  r13 = heapClassInst.heap32[r2 + numDefine4];
                  r13 = r13 >> numDefine2;
                  r14 = heapClassInst.heap32[r13 + 1];
                  if (r14 !== r12) {
                    r13 = heapClassInst.heap32[r7 + 1];
                    r13 = r13 >> numDefine2;
                    r14 = heapClassInst.heap32[r13 + numDefine3];
                    if (r14 !== r12) {
                      heapClassInst.heap32[r13 + numDefine2] = r10;
                    } else {
                      heapClassInst.heap32[r13 + numDefine3] = r10;
                    }
                  } else {
                    heapClassInst.heap32[r13 + 1] = r10;
                  }
                  heapClassInst.heap32[r11 + numDefine3] = r12;
                  heapClassInst.heap32[r7 + 1] = r10;
                  label = numDefine140;
                  break repeat177;
                case numDefine93:
                  r10 = r10 >> numDefine2;
                  r11 = heapClassInst.heap32[r7];
                  heapClassInst.heap32[r10] = r11;
                  heapClassInst.heap32[r7] = 1;
                  r10 = heapClassInst.heap32[r10 + numDefine3];
                  if (!(r10 === 0)) {
                    r10 = r10 >> numDefine2;
                    heapClassInst.heap32[r10] = 1;
                  }
                  r10 = heapClassInst.heap32[r7 + numDefine3];
                  r11 = r10 >> numDefine2;
                  r13 = heapClassInst.heap32[r11 + numDefine2];
                  heapClassInst.heap32[r7 + numDefine3] = r13;
                  r13 = heapClassInst.heap32[r11 + numDefine2];
                  if (!(r13 === 0)) {
                    r13 = r13 >> numDefine2;
                    heapClassInst.heap32[r13 + 1] = r12;
                  }
                  r13 = heapClassInst.heap32[r7 + 1];
                  heapClassInst.heap32[r11 + 1] = r13;
                  r13 = heapClassInst.heap32[r2 + numDefine4];
                  r13 = r13 >> numDefine2;
                  r14 = heapClassInst.heap32[r13 + 1];
                  if (r14 !== r12) {
                    r13 = heapClassInst.heap32[r7 + 1];
                    r13 = r13 >> numDefine2;
                    r14 = heapClassInst.heap32[r13 + numDefine2];
                    if (r14 !== r12) {
                      heapClassInst.heap32[r13 + numDefine3] = r10;
                    } else {
                      heapClassInst.heap32[r13 + numDefine2] = r10;
                    }
                  } else {
                    heapClassInst.heap32[r13 + 1] = r10;
                  }
                  heapClassInst.heap32[r11 + numDefine2] = r12;
                  heapClassInst.heap32[r7 + 1] = r10;
                  label = numDefine140;
                  break;
                default:
                  break;
              }
            } while (false);
            if (label === numDefine140) {
              if (r9 === 0) {
                break repeat99;
              }
            }
            r7 = r9 >> numDefine2;
            heapClassInst.heap32[r7] = 1;
          }
        } while (false);
        r7 = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[r3 + numDefine3] = r7;
        r7 = heapClassInst.heap32[r3 + numDefine4];
        r7 = (r7 + numDefineNeg12) | 0;
        r9 = znss11CNullRefE;
        if (!(r7 === r9)) {
          r7 = r7 >> numDefine2;
          r9 = heapClassInst.heap32[r7];
          r10 = (r9 + -1) | 0;
          heapClassInst.heap32[r7] = r10;
          if (!(r9 > 0)) {
            r7 = heapClassInst.heap32[r3 + numDefine4];
            r7 = (r7 + numDefineNeg12) | 0;
            heapClassInst.heap32[g0] = r7;
            zdlPv(i7);
          }
        }
        heapClassInst.heap32[r3 + numDefine4] = 0;
        heapClassInst.heap32[r2 + 1] = r4;
        r4 = heapClassInst.heap32[r2 + numDefine5];
        r4 = (r4 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine5] = r4;
      } else {
        r8 = r7;
      }
      heapClassInst.heap32[r1] = r8;
      r4 = r5;
      if (r5 !== r6) {
        continue repeat7;
      } else {
        break repeat7;
      }
    }
  }
  return;
}

function zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE5eraseENS14RwTreeIterIS6IPS6RS6NS17RwRbTreeNodeISBS6JS8EEEE(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = zn5myGlL9mContextE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine78];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp];
  if (r1 !== r2) {
    r4 = r2 >> numDefine2;
    r5 = heapClassInst.heap32[r4 + numDefine3];
    repeat3: do {
      if (r5 !== 0) {
        r6 = r5 >> numDefine2;
        r7 = heapClassInst.heap32[r6 + numDefine2];
        if (r7 === 0) {
          r6 = r5;
        } else {
          repeat7: while (true) {
            r6 = r7;
            r7 = r6 >> numDefine2;
            r7 = heapClassInst.heap32[r7 + numDefine2];
            if (r7 !== 0) {
              continue repeat7;
            } else {
              break repeat3;
            }
          }
        }
      } else {
        r6 = heapClassInst.heap32[r4 + 1];
        r7 = r6 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + numDefine3];
        if (r7 === r2) {
          repeat11: while (true) {
            r8 = r6;
            r7 = r8 >> numDefine2;
            r6 = heapClassInst.heap32[r7 + 1];
            r9 = r6 >> numDefine2;
            r9 = heapClassInst.heap32[r9 + numDefine3];
            if (!(r8 === r9)) {
              break repeat11;
            }
          }
          r7 = heapClassInst.heap32[r7 + numDefine3];
        } else {
          r7 = 0;
          r8 = r2;
        }
        if (r7 === r6) {
          r6 = r8;
        }
      }
    } while (false);
    r7 = heapClassInst.heap32[r4 + numDefine2];
    if (r7 !== 0) {
      if (r5 !== 0) {
        r8 = r5 >> numDefine2;
        r9 = heapClassInst.heap32[r8 + numDefine2];
        repeat22: do {
          if (r9 === 0) {
            r8 = r5;
          } else {
            while (true) {
              r8 = r9;
              r9 = r8 >> numDefine2;
              r9 = heapClassInst.heap32[r9 + numDefine2];
              if (!(r9 !== 0)) {
                break repeat22;
              }
            }
          }
        } while (false);
        r10 = r8 >> numDefine2;
        r5 = heapClassInst.heap32[r10 + numDefine3];
        if (r8 !== r2) {
          r9 = r7 >> numDefine2;
          heapClassInst.heap32[r9 + 1] = r8;
          r9 = heapClassInst.heap32[r4 + numDefine2];
          heapClassInst.heap32[r10 + numDefine2] = r9;
          r9 = heapClassInst.heap32[r4 + numDefine3];
          if (r9 !== r8) {
            r9 = heapClassInst.heap32[r10 + 1];
            if (r5 !== 0) {
              r7 = r5 >> numDefine2;
              heapClassInst.heap32[r7 + 1] = r9;
              r7 = heapClassInst.heap32[r10 + 1];
            } else {
              r7 = r9;
            }
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7 + numDefine2] = r5;
            r7 = heapClassInst.heap32[r4 + numDefine3];
            heapClassInst.heap32[r10 + numDefine3] = r7;
            r7 = heapClassInst.heap32[r4 + numDefine3];
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7 + 1] = r8;
          } else {
            r9 = r8;
          }
          r7 = r1 >> numDefine2;
          r11 = heapClassInst.heap32[r7 + 1];
          if (r11 !== r2) {
            r11 = heapClassInst.heap32[r4 + 1];
            r7 = r11 >> numDefine2;
            r7 = heapClassInst.heap32[r7 + numDefine2];

            r7 = r7 !== r2 ? 1 : 0;
            r7 = r7 & 1;
            r7 = r7 << numDefine2;
            r11 = (r11 + r7) | 0;
            r7 = (r11 + numDefine8) | 0;
            r11 = (r2 + numDefine4) | 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7] = r8;
          } else {
            r11 = (r2 + numDefine4) | 0;
            heapClassInst.heap32[r7 + 1] = r8;
          }
          r8 = r11 >> numDefine2;
          r8 = heapClassInst.heap32[r8];
          heapClassInst.heap32[r10 + 1] = r8;
          r8 = heapClassInst.heap32[r10];
          r7 = heapClassInst.heap32[r4];
          heapClassInst.heap32[r10] = r7;
          heapClassInst.heap32[r4] = r8;
          label = numDefine51;
        } else {
          label = numDefine30;
        }
      } else {
        r9 = heapClassInst.heap32[r4 + 1];
        r8 = r2;
        r5 = r7;
        label = numDefine32;
      }
    } else {
      r8 = r2;
      label = numDefine30;
    }
    if (label === numDefine30) {
      r9 = r8 >> numDefine2;
      r9 = heapClassInst.heap32[r9 + 1];
      if (r5 === 0) {
        r5 = 0;
        label = numDefine33;
      } else {
        label = numDefine32;
      }
    }
    if (label === numDefine32) {
      r7 = r5 >> numDefine2;
      heapClassInst.heap32[r7 + 1] = r9;
      label = numDefine33;
    }
    if (label === numDefine33) {
      r7 = r1 >> numDefine2;
      r10 = heapClassInst.heap32[r7 + 1];
      if (r10 !== r2) {
        r10 = heapClassInst.heap32[r4 + 1];
        r11 = r10 >> numDefine2;
        r11 = heapClassInst.heap32[r11 + numDefine2];

        r11 = r11 !== r2 ? 1 : 0;
        r11 = r11 & 1;
        r11 = r11 << numDefine2;
        r10 = (r10 + r11) | 0;
        r10 = (r10 + numDefine8) | 0;
        r10 = r10 >> numDefine2;
        heapClassInst.heap32[r10] = r5;
      } else {
        heapClassInst.heap32[r7 + 1] = r5;
      }
      r10 = heapClassInst.heap32[r7 + numDefine2];
      if (!(r10 !== r2)) {
        r10 = heapClassInst.heap32[r4 + numDefine3];
        if (r10 !== 0) {
          r10 = r5 >> numDefine2;
          r10 = heapClassInst.heap32[r10 + numDefine2];
          repeat57: do {
            if (r10 === 0) {
              r11 = r5;
            } else {
              while (true) {
                r11 = r10;
                r10 = r11 >> numDefine2;
                r10 = heapClassInst.heap32[r10 + numDefine2];
                if (!(r10 !== 0)) {
                  break repeat57;
                }
              }
            }
          } while (false);
          heapClassInst.heap32[r7 + numDefine2] = r11;
        } else {
          r10 = heapClassInst.heap32[r4 + 1];
          heapClassInst.heap32[r7 + numDefine2] = r10;
        }
      }
      r10 = heapClassInst.heap32[r7 + numDefine3];
      if (r10 === r2) {
        r2 = heapClassInst.heap32[r4 + numDefine2];
        if (r2 !== 0) {
          r2 = r5 >> numDefine2;
          r2 = heapClassInst.heap32[r2 + numDefine3];
          repeat68: do {
            if (r2 === 0) {
              r4 = r5;
            } else {
              while (true) {
                r4 = r2;
                r2 = r4 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine3];
                if (!(r2 !== 0)) {
                  break repeat68;
                }
              }
            }
          } while (false);
          heapClassInst.heap32[r7 + numDefine3] = r4;
          r2 = r8;
        } else {
          r2 = heapClassInst.heap32[r4 + 1];
          heapClassInst.heap32[r7 + numDefine3] = r2;
          r2 = r8;
        }
      } else {
        r2 = r8;
      }
    }
    r4 = r2 >> numDefine2;
    r7 = heapClassInst.heap32[r4];
    repeat76: do {
      if (!(r7 === 0)) {
        repeat77: while (true) {
          r7 = r1 >> numDefine2;
          r8 = heapClassInst.heap32[r7 + 1];
          if (r8 === r5) {
            label = numDefine125;
            break repeat77;
          } else {
            if (!(r5 === 0)) {
              r8 = r5 >> numDefine2;
              r8 = heapClassInst.heap32[r8];
              if (!(r8 === 1)) {
                label = numDefine126;
                break repeat77;
              }
            }
            r8 = r9 >> numDefine2;
            r10 = heapClassInst.heap32[r8 + numDefine2];
            if (r10 !== r5) {
              r11 = r10 >> numDefine2;
              r12 = heapClassInst.heap32[r11];
              if (r12 === 0) {
                heapClassInst.heap32[r11] = 1;
                heapClassInst.heap32[r8] = 0;
                r10 = heapClassInst.heap32[r8 + numDefine2];
                r11 = r10 >> numDefine2;
                r12 = heapClassInst.heap32[r11 + numDefine3];
                heapClassInst.heap32[r8 + numDefine2] = r12;
                r12 = heapClassInst.heap32[r11 + numDefine3];
                if (!(r12 === 0)) {
                  r12 = r12 >> numDefine2;
                  heapClassInst.heap32[r12 + 1] = r9;
                }
                r12 = heapClassInst.heap32[r8 + 1];
                heapClassInst.heap32[r11 + 1] = r12;
                r12 = heapClassInst.heap32[r7 + 1];
                if (r12 !== r9) {
                  r12 = heapClassInst.heap32[r8 + 1];
                  r12 = r12 >> numDefine2;
                  r13 = heapClassInst.heap32[r12 + numDefine3];
                  if (r13 !== r9) {
                    heapClassInst.heap32[r12 + numDefine2] = r10;
                  } else {
                    heapClassInst.heap32[r12 + numDefine3] = r10;
                  }
                } else {
                  heapClassInst.heap32[r7 + 1] = r10;
                }
                heapClassInst.heap32[r11 + numDefine3] = r9;
                heapClassInst.heap32[r8 + 1] = r10;
                r10 = heapClassInst.heap32[r8 + numDefine2];
              }
              r11 = r10 >> numDefine2;
              r12 = heapClassInst.heap32[r11 + numDefine3];
              if (!(r12 === 0)) {
                r12 = r12 >> numDefine2;
                r13 = heapClassInst.heap32[r12];
                if (r13 !== 1) {
                  label = numDefine102;
                  break repeat77;
                }
              }
              r12 = heapClassInst.heap32[r11 + numDefine2];
              if (!(r12 === 0)) {
                r12 = r12 >> numDefine2;
                r12 = heapClassInst.heap32[r12];
                if (!(r12 === 1)) {
                  label = numDefine112;
                  break repeat77;
                }
              }
              heapClassInst.heap32[r11] = 0;
            } else {
              r10 = heapClassInst.heap32[r8 + numDefine3];
              r11 = r10 >> numDefine2;
              r12 = heapClassInst.heap32[r11];
              if (r12 === 0) {
                heapClassInst.heap32[r11] = 1;
                heapClassInst.heap32[r8] = 0;
                r10 = heapClassInst.heap32[r8 + numDefine3];
                r11 = r10 >> numDefine2;
                r12 = heapClassInst.heap32[r11 + numDefine2];
                heapClassInst.heap32[r8 + numDefine3] = r12;
                r12 = heapClassInst.heap32[r11 + numDefine2];
                if (!(r12 === 0)) {
                  r12 = r12 >> numDefine2;
                  heapClassInst.heap32[r12 + 1] = r9;
                }
                r12 = heapClassInst.heap32[r8 + 1];
                heapClassInst.heap32[r11 + 1] = r12;
                r12 = heapClassInst.heap32[r7 + 1];
                if (r12 !== r9) {
                  r12 = heapClassInst.heap32[r8 + 1];
                  r12 = r12 >> numDefine2;
                  r13 = heapClassInst.heap32[r12 + numDefine2];
                  if (r13 !== r9) {
                    heapClassInst.heap32[r12 + numDefine3] = r10;
                  } else {
                    heapClassInst.heap32[r12 + numDefine2] = r10;
                  }
                } else {
                  heapClassInst.heap32[r7 + 1] = r10;
                }
                heapClassInst.heap32[r11 + numDefine2] = r9;
                heapClassInst.heap32[r8 + 1] = r10;
                r10 = heapClassInst.heap32[r8 + numDefine3];
              }
              r11 = r10 >> numDefine2;
              r12 = heapClassInst.heap32[r11 + numDefine2];
              if (!(r12 === 0)) {
                r12 = r12 >> numDefine2;
                r13 = heapClassInst.heap32[r12];
                if (r13 !== 1) {
                  label = numDefine68;
                  break repeat77;
                }
              }
              r12 = heapClassInst.heap32[r11 + numDefine3];
              if (!(r12 === 0)) {
                r12 = r12 >> numDefine2;
                r12 = heapClassInst.heap32[r12];
                if (!(r12 === 1)) {
                  label = numDefine78;
                  break repeat77;
                }
              }
              heapClassInst.heap32[r11] = 0;
            }
            r10 = heapClassInst.heap32[r8 + 1];
            r5 = r9;
            r9 = r10;
          }
        }
        repeat125: do {
          switch (label) {
            case numDefine102:
              r1 = heapClassInst.heap32[r11 + numDefine2];
              if (!(r1 === 0)) {
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1];
                if (r1 !== 1) {
                  label = numDefine112;
                  break repeat125;
                }
              }
              heapClassInst.heap32[r12] = 1;
              r1 = heapClassInst.heap32[r11 + numDefine3];
              r12 = r1 >> numDefine2;
              heapClassInst.heap32[r11] = 0;
              r13 = heapClassInst.heap32[r12 + numDefine2];
              heapClassInst.heap32[r11 + numDefine3] = r13;
              r13 = heapClassInst.heap32[r12 + numDefine2];
              if (!(r13 === 0)) {
                r13 = r13 >> numDefine2;
                heapClassInst.heap32[r13 + 1] = r10;
              }
              r13 = heapClassInst.heap32[r11 + 1];
              heapClassInst.heap32[r12 + 1] = r13;
              r13 = heapClassInst.heap32[r7 + 1];
              if (r13 !== r10) {
                r13 = heapClassInst.heap32[r11 + 1];
                r13 = r13 >> numDefine2;
                r14 = heapClassInst.heap32[r13 + numDefine2];
                if (r14 !== r10) {
                  heapClassInst.heap32[r13 + numDefine3] = r1;
                } else {
                  heapClassInst.heap32[r13 + numDefine2] = r1;
                }
              } else {
                heapClassInst.heap32[r7 + 1] = r1;
              }
              heapClassInst.heap32[r12 + numDefine2] = r10;
              heapClassInst.heap32[r11 + 1] = r1;
              r10 = heapClassInst.heap32[r8 + numDefine2];
              label = numDefine112;
              break repeat125;
            case numDefine68:
              r1 = heapClassInst.heap32[r11 + numDefine3];
              if (!(r1 === 0)) {
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1];
                if (r1 !== 1) {
                  label = numDefine78;
                  break repeat125;
                }
              }
              heapClassInst.heap32[r12] = 1;
              r1 = heapClassInst.heap32[r11 + numDefine2];
              r12 = r1 >> numDefine2;
              heapClassInst.heap32[r11] = 0;
              r13 = heapClassInst.heap32[r12 + numDefine3];
              heapClassInst.heap32[r11 + numDefine2] = r13;
              r13 = heapClassInst.heap32[r12 + numDefine3];
              if (!(r13 === 0)) {
                r13 = r13 >> numDefine2;
                heapClassInst.heap32[r13 + 1] = r10;
              }
              r13 = heapClassInst.heap32[r11 + 1];
              heapClassInst.heap32[r12 + 1] = r13;
              r13 = heapClassInst.heap32[r7 + 1];
              if (r13 !== r10) {
                r13 = heapClassInst.heap32[r11 + 1];
                r13 = r13 >> numDefine2;
                r14 = heapClassInst.heap32[r13 + numDefine3];
                if (r14 !== r10) {
                  heapClassInst.heap32[r13 + numDefine2] = r1;
                } else {
                  heapClassInst.heap32[r13 + numDefine3] = r1;
                }
              } else {
                heapClassInst.heap32[r7 + 1] = r1;
              }
              heapClassInst.heap32[r12 + numDefine3] = r10;
              heapClassInst.heap32[r11 + 1] = r1;
              r10 = heapClassInst.heap32[r8 + numDefine3];
              label = numDefine78;
              break;
            default:
              break;
          }
        } while (false);
        repeat154: do {
          switch (label) {
            case numDefine112:
              r1 = r10 >> numDefine2;
              r10 = heapClassInst.heap32[r8];
              heapClassInst.heap32[r1] = r10;
              heapClassInst.heap32[r8] = 1;
              r1 = heapClassInst.heap32[r1 + numDefine2];
              if (!(r1 === 0)) {
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r1] = 1;
              }
              r1 = heapClassInst.heap32[r8 + numDefine2];
              r10 = r1 >> numDefine2;
              r11 = heapClassInst.heap32[r10 + numDefine3];
              heapClassInst.heap32[r8 + numDefine2] = r11;
              r11 = heapClassInst.heap32[r10 + numDefine3];
              if (!(r11 === 0)) {
                r11 = r11 >> numDefine2;
                heapClassInst.heap32[r11 + 1] = r9;
              }
              r11 = heapClassInst.heap32[r8 + 1];
              heapClassInst.heap32[r10 + 1] = r11;
              r11 = heapClassInst.heap32[r7 + 1];
              if (r11 !== r9) {
                r7 = heapClassInst.heap32[r8 + 1];
                r7 = r7 >> numDefine2;
                r11 = heapClassInst.heap32[r7 + numDefine3];
                if (r11 !== r9) {
                  heapClassInst.heap32[r7 + numDefine2] = r1;
                } else {
                  heapClassInst.heap32[r7 + numDefine3] = r1;
                }
              } else {
                heapClassInst.heap32[r7 + 1] = r1;
              }
              heapClassInst.heap32[r10 + numDefine3] = r9;
              heapClassInst.heap32[r8 + 1] = r1;
              label = numDefine125;
              break repeat154;
            case numDefine78:
              r1 = r10 >> numDefine2;
              r10 = heapClassInst.heap32[r8];
              heapClassInst.heap32[r1] = r10;
              heapClassInst.heap32[r8] = 1;
              r1 = heapClassInst.heap32[r1 + numDefine3];
              if (!(r1 === 0)) {
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r1] = 1;
              }
              r1 = heapClassInst.heap32[r8 + numDefine3];
              r10 = r1 >> numDefine2;
              r11 = heapClassInst.heap32[r10 + numDefine2];
              heapClassInst.heap32[r8 + numDefine3] = r11;
              r11 = heapClassInst.heap32[r10 + numDefine2];
              if (!(r11 === 0)) {
                r11 = r11 >> numDefine2;
                heapClassInst.heap32[r11 + 1] = r9;
              }
              r11 = heapClassInst.heap32[r8 + 1];
              heapClassInst.heap32[r10 + 1] = r11;
              r11 = heapClassInst.heap32[r7 + 1];
              if (r11 !== r9) {
                r7 = heapClassInst.heap32[r8 + 1];
                r7 = r7 >> numDefine2;
                r11 = heapClassInst.heap32[r7 + numDefine2];
                if (r11 !== r9) {
                  heapClassInst.heap32[r7 + numDefine3] = r1;
                } else {
                  heapClassInst.heap32[r7 + numDefine2] = r1;
                }
              } else {
                heapClassInst.heap32[r7 + 1] = r1;
              }
              heapClassInst.heap32[r10 + numDefine2] = r9;
              heapClassInst.heap32[r8 + 1] = r1;
              label = numDefine125;
              break;
            default:
              break;
          }
        } while (false);
        if (label === numDefine125) {
          if (r5 === 0) {
            break repeat76;
          }
        }
        r1 = r5 >> numDefine2;
        heapClassInst.heap32[r1] = 1;
      }
    } while (false);
    r1 = heapClassInst.heap32[r0 + numDefine75];
    heapClassInst.heap32[r4 + numDefine3] = r1;
    heapClassInst.heap32[r0 + numDefine75] = r2;
    r1 = heapClassInst.heap32[r0 + numDefine79];
    r1 = (r1 + -1) | 0;
    r2 = r3 >> numDefine2;
    heapClassInst.heap32[r0 + numDefine79] = r1;
    heapClassInst.heap32[r2] = r6;
    return;
  } else {
    r0 = r3 >> numDefine2;
    heapClassInst.heap32[r0] = r1;
    return;
  }
}

function zn4Rw9RbTreeIjSt4pairIKjPN5myGl12TIndexBufferEENS11Select1stIS6JEESt4lessIjESaIS6EE11CGetLinkEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zn5myGlL9mContextE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine75];
  if (r1 === 0) {
    r1 = heapClassInst.heap32[r0 + numDefine76];
    r2 = heapClassInst.heap32[r0 + numDefine77];
    if (r1 !== r2) {
      r2 = (r1 + numDefine24) | 0;
      heapClassInst.heap32[r0 + numDefine76] = r2;
    } else {
      r1 = heapClassInst.heap32[r0 + numDefine74];
      if (r1 !== 0) {
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + 1];
      } else {
        r1 = 0;
      }
      heapClassInst.heap32[g0] = numDefine12;
      znwj(i7);
      r2 = commonVariable.rg0;
      if (!(r2 !== 0)) {
        heapClassInst.heap32[g0] = numDefine3;
        zn4Rw10RwThrowEiz(i7);
      }
      r3 = r1 & numDefine1023;
      r3 = (r3 * numDefine1656) | 0;
      r4 = r1 >>> numDefine10;
      r3 = r3 >>> numDefine10;
      r4 = (r4 * numDefine1656) | 0;
      r5 = (r1 + numDefine32) | 0;
      r3 = (r3 + r4) | 0;
      r3 = uint(r5) > uint(r3) ? r5 : r3;
      r4 = (r1 + 1) | 0;
      r3 = uint(r3) > uint(r1) ? r3 : r4;
      r4 = (r3 * numDefine24) | 0;
      heapClassInst.heap32[g0] = r4;
      znwj(i7);
      r1 = commonVariable.rg0;
      if (!(r1 !== 0)) {
        heapClassInst.heap32[g0] = numDefine3;
        zn4Rw10RwThrowEiz(i7);
      }
      r5 = r2 >> numDefine2;
      heapClassInst.heap32[r5 + numDefine2] = r1;
      r6 = heapClassInst.heap32[r0 + numDefine74];
      heapClassInst.heap32[r5] = r6;
      heapClassInst.heap32[r5 + 1] = r3;
      r3 = (r1 + r4) | 0;
      heapClassInst.heap32[r0 + numDefine74] = r2;
      r2 = (r1 + numDefine24) | 0;
      heapClassInst.heap32[r0 + numDefine77] = r3;
      heapClassInst.heap32[r0 + numDefine76] = r2;
    }
  } else {
    r2 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + numDefine3];
    heapClassInst.heap32[r0 + numDefine75] = r2;
  }
  r0 = r1 >> numDefine2;
  heapClassInst.heap32[r0 + 1] = 0;
  heapClassInst.heap32[r0 + numDefine2] = 0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  heapClassInst.heap32[r0] = 0;
  commonVariable.rg0 = r1;
  return;
}

function zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EED2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine4];
  if (!(r2 === 0)) {
    r3 = r2 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine2];
    heapClassInst.heap32[fp + numDefineNeg2] = r3;
    r3 = sp + numDefineNeg16;
    r4 = sp + numDefineNeg8;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r2;
    zn4Rw9RbTreeISsSt4pairIKSsiENS11Select1stIS3SsEESt4lessISsESaIS3EE5eraseENS14RwTreeIterIS3IPS3RS3NS17RwRbTreeNodeIS8S3SsS5EEEESF(i7);
    r0 = heapClassInst.heap32[r1 + numDefine4];
    r2 = heapClassInst.heap32[r1 + 1];
    r3 = r0 >> numDefine2;
    heapClassInst.heap32[r3 + numDefine3] = r2;
    heapClassInst.heap32[r1 + 1] = r0;
    r0 = heapClassInst.heap32[r1];
    if (!(r0 === 0)) {
      label = numDefine2;
      repeat3: while (true) {
        r2 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r2];
        heapClassInst.heap32[r1] = r3;
        r2 = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[g0] = r2;
        zdlPv(i7);
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        r0 = heapClassInst.heap32[r1];
        if (r0 !== 0) {
          continue repeat3;
        } else {
          break repeat3;
        }
      }
    }
  }
  return;
}

function mandreelTextureAsyncLoaded(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = numDefine5;
  r0 = heapClassInst.heap32[r0];
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = 0;
  heapClassInst.heap32[g0 + 1] = numDefine3553;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  r2 = numDefine100;
  functionTable[r0 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = 0;
  heapClassInst.heap32[g0 + 1] = numDefine3553;
  heapClassInst.heap32[g0 + numDefine2] = 0;
  heapClassInst.heap32[g0 + numDefine3] = numDefine6408;
  heapClassInst.heap32[g0 + numDefine4] = r2;
  heapClassInst.heap32[g0 + numDefine5] = r3;
  heapClassInst.heap32[g0 + numDefine6] = 0;
  heapClassInst.heap32[g0 + numDefine7] = numDefine6408;
  heapClassInst.heap32[g0 + numDefine8] = numDefine5121;
  heapClassInst.heap32[g0 + numDefine9] = 0;
  functionTable[r0 >> numDefine2](i7);
  heapClassInst.heap32[g0] = r1;
  mandreelTextureAsyncSetData(i7);
  return;
}

export { mandreelInternalPreupdate, mandreelInternalUpdate, mouseWheelDelta, mouseMove, mouseButton, mouseDoubleClick, keyEvent, tlsfFree };

export {
  znss10CGetRepEjj,
  fprintf,
  quicksort,
  strcmp,
  zn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEE,
  zn4Rw14RwPodArrayIcLj256EE6appendEPKcj,
  strncmp,
  mandreelFlashTcpOnConnect,
  mandreelFlashTcpReceiveCallbak,
  globalIzn5myGl14glAttachShaderEjj,
  zn10CFileCloud4feofEv,
  zn10CFileCloud5freadEPvjj,
  zn10CFileCloud5fseekEli,
  zn10CFileCloud5ftellEv,
  zn10CFileCloud6fcloseEv,
  zn10CFileCloud6fflushEv,
  zn10CFileCloud6fwriteEPKvjj,
  zn10CFileCloud6ungetcEi,
  globalIMandreelCreateTcpSocket,
  zn10Cxxabiv117ClassTypeInfoD0Ev,
  zn10Cxxabiv117ClassTypeInfoD1Ev,
  zn10Cxxabiv120SiClassTypeInfoD0Ev,
  zn10Cxxabiv120SiClassTypeInfoD1Ev,
  zn10Cxxabiv121VmiClassTypeInfoD0Ev,
  zn10Cxxabiv121VmiClassTypeInfoD1Ev,
  globalDzn5myGl14glAttachShaderEjj,
  globalDzn8OpenGLES12OpenGLESUtil15getCurrentErrorEv,
  zn11CFileStdout4feofEv,
  zn11CFileStdout5freadEPvjj,
  zn11CFileStdout5fseekEli,
  zn11CFileStdout5ftellEv,
  zn11CFileStdout6fcloseEv,
  zn11CFileStdout6fflushEv,
  zn11CFileStdout6fwriteEPKvjj,
  zn11CFileStdout6ungetcEi,
  zn11CFileSystem4feofEv,
  zn11CFileSystem5freadEPvjj,
  zn11CFileSystem5fseekEli,
  zn11CFileSystem5ftellEv,
  zn11CFileSystem6fcloseEv,
  zn11CFileSystem6fflushEv,
  zn11CFileSystem6fwriteEPKvjj,
  zn11CFileSystem6ungetcEi,
  zn7CFileLS4feofEv,
  zn7CFileLS5freadEPvjj,
  zn7CFileLS5fseekEli,
  zn7CFileLS5ftellEv,
  zn7CFileLS6fcloseEv,
  zn7CFileLS6fflushEv,
  zn7CFileLS6fwriteEPKvjj,
  zn7CFileLS6ungetcEi,
  znk10Cxxabiv117ClassTypeInfo10DoCatchEPKSt9typeInfoPPvj,
  znk10Cxxabiv117ClassTypeInfo11DoUpcastEPKS0PKvRNS015UpcastResultE,
  znk10Cxxabiv117ClassTypeInfo11DoUpcastEPKS0PPv,
  znk10Cxxabiv117ClassTypeInfo12DoDyncastEiNS010SubKindEPKS0PKvS3S5RNS016DyncastResultE,
  znk10Cxxabiv117ClassTypeInfo20DoFindPublicSrcEiPKvPKS0S2,
  znk10Cxxabiv120SiClassTypeInfo11DoUpcastEPKNS17ClassTypeInfoEPKvRNS115UpcastResultE,
  znk10Cxxabiv120SiClassTypeInfo12DoDyncastEiNS17ClassTypeInfo10SubKindEPKS1PKvS4S6RNS116DyncastResultE,
  znk10Cxxabiv120SiClassTypeInfo20DoFindPublicSrcEiPKvPKNS17ClassTypeInfoES2,
  znk10Cxxabiv121VmiClassTypeInfo11DoUpcastEPKNS17ClassTypeInfoEPKvRNS115UpcastResultE,
  znk10Cxxabiv121VmiClassTypeInfo12DoDyncastEiNS17ClassTypeInfo10SubKindEPKS1PKvS4S6RNS116DyncastResultE,
  znk10Cxxabiv121VmiClassTypeInfo20DoFindPublicSrcEiPKvPKNS17ClassTypeInfoES2,
  znk11CFileSystem12IsFileSystemEv,
  znk14CFileInterface12IsFileSystemEv,
  znkst8messagesIcE6doGetEiiiRKSs,
  znkst8messagesIcE7doOpenERKSsRKSt6locale,
  znkst8messagesIcE8doCloseEi,
  znkst9typeInfo10DoCatchEPKSPPvj,
  znkst9typeInfo15IsFunctionPEv,
  znst8messagesIcED0Ev,
  znst8messagesIcED1Ev,
  znst9typeInfoD0Ev,
  znst9typeInfoD1Ev,
  mandreelInternalInit,
  sscanf,
  zn4Rw10RwThrowEiz
};
